// Copyright 2025 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// Code generated by sidekick. DO NOT EDIT.

//! Traits to mock the clients in this library.
//!
//! Application developers may need to mock the clients in this library to test
//! how their application works with different (and sometimes hard to trigger)
//! client and service behavior. Such test can define mocks implementing the
//! trait(s) defined in this module, initialize the client with an instance of
//! this mock in their tests, and verify their application responds as expected.

#![allow(rustdoc::broken_intra_doc_links)]

pub(crate) mod dynamic;

/// Defines the trait used to implement [super::client::AcceleratorTypes].
///
/// Application developers may need to implement this trait to mock
/// `client::AcceleratorTypes`.  In other use-cases, application developers only
/// use `client::AcceleratorTypes` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "accelerator-types")]
#[cfg_attr(docsrs, doc(cfg(feature = "accelerator-types")))]
pub trait AcceleratorTypes: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::AcceleratorTypes::aggregated_list].
    fn aggregated_list(
        &self,
        _req: crate::model::accelerator_types::AggregatedListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<
            gax::response::Response<crate::model::AcceleratorTypeAggregatedList>,
        >,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::AcceleratorTypes::get].
    fn get(
        &self,
        _req: crate::model::accelerator_types::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::AcceleratorType>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::AcceleratorTypes::list].
    fn list(
        &self,
        _req: crate::model::accelerator_types::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::AcceleratorTypeList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }
}

/// Defines the trait used to implement [super::client::Addresses].
///
/// Application developers may need to implement this trait to mock
/// `client::Addresses`.  In other use-cases, application developers only
/// use `client::Addresses` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "addresses")]
#[cfg_attr(docsrs, doc(cfg(feature = "addresses")))]
pub trait Addresses: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::Addresses::aggregated_list].
    fn aggregated_list(
        &self,
        _req: crate::model::addresses::AggregatedListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::AddressAggregatedList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Addresses::delete].
    fn delete(
        &self,
        _req: crate::model::addresses::DeleteRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Addresses::get].
    fn get(
        &self,
        _req: crate::model::addresses::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Address>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Addresses::insert].
    fn insert(
        &self,
        _req: crate::model::addresses::InsertRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Addresses::list].
    fn list(
        &self,
        _req: crate::model::addresses::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::AddressList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Addresses::r#move].
    fn r#move(
        &self,
        _req: crate::model::addresses::MoveRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Addresses::set_labels].
    fn set_labels(
        &self,
        _req: crate::model::addresses::SetLabelsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Addresses::test_iam_permissions].
    fn test_iam_permissions(
        &self,
        _req: crate::model::addresses::TestIamPermissionsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Addresses::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::region_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::Advice].
///
/// Application developers may need to implement this trait to mock
/// `client::Advice`.  In other use-cases, application developers only
/// use `client::Advice` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "advice")]
#[cfg_attr(docsrs, doc(cfg(feature = "advice")))]
pub trait Advice: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::Advice::calendar_mode].
    fn calendar_mode(
        &self,
        _req: crate::model::advice::CalendarModeRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::CalendarModeAdviceResponse>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }
}

/// Defines the trait used to implement [super::client::Autoscalers].
///
/// Application developers may need to implement this trait to mock
/// `client::Autoscalers`.  In other use-cases, application developers only
/// use `client::Autoscalers` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "autoscalers")]
#[cfg_attr(docsrs, doc(cfg(feature = "autoscalers")))]
pub trait Autoscalers: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::Autoscalers::aggregated_list].
    fn aggregated_list(
        &self,
        _req: crate::model::autoscalers::AggregatedListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::AutoscalerAggregatedList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Autoscalers::delete].
    fn delete(
        &self,
        _req: crate::model::autoscalers::DeleteRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Autoscalers::get].
    fn get(
        &self,
        _req: crate::model::autoscalers::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Autoscaler>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Autoscalers::insert].
    fn insert(
        &self,
        _req: crate::model::autoscalers::InsertRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Autoscalers::list].
    fn list(
        &self,
        _req: crate::model::autoscalers::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::AutoscalerList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Autoscalers::patch].
    fn patch(
        &self,
        _req: crate::model::autoscalers::PatchRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Autoscalers::update].
    fn update(
        &self,
        _req: crate::model::autoscalers::UpdateRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Autoscalers::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::zone_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::BackendBuckets].
///
/// Application developers may need to implement this trait to mock
/// `client::BackendBuckets`.  In other use-cases, application developers only
/// use `client::BackendBuckets` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "backend-buckets")]
#[cfg_attr(docsrs, doc(cfg(feature = "backend-buckets")))]
pub trait BackendBuckets: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::BackendBuckets::add_signed_url_key].
    fn add_signed_url_key(
        &self,
        _req: crate::model::backend_buckets::AddSignedUrlKeyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::BackendBuckets::delete].
    fn delete(
        &self,
        _req: crate::model::backend_buckets::DeleteRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::BackendBuckets::delete_signed_url_key].
    fn delete_signed_url_key(
        &self,
        _req: crate::model::backend_buckets::DeleteSignedUrlKeyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::BackendBuckets::get].
    fn get(
        &self,
        _req: crate::model::backend_buckets::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::BackendBucket>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::BackendBuckets::get_iam_policy].
    fn get_iam_policy(
        &self,
        _req: crate::model::backend_buckets::GetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Policy>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::BackendBuckets::insert].
    fn insert(
        &self,
        _req: crate::model::backend_buckets::InsertRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::BackendBuckets::list].
    fn list(
        &self,
        _req: crate::model::backend_buckets::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::BackendBucketList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::BackendBuckets::patch].
    fn patch(
        &self,
        _req: crate::model::backend_buckets::PatchRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::BackendBuckets::set_edge_security_policy].
    fn set_edge_security_policy(
        &self,
        _req: crate::model::backend_buckets::SetEdgeSecurityPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::BackendBuckets::set_iam_policy].
    fn set_iam_policy(
        &self,
        _req: crate::model::backend_buckets::SetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Policy>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::BackendBuckets::test_iam_permissions].
    fn test_iam_permissions(
        &self,
        _req: crate::model::backend_buckets::TestIamPermissionsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::BackendBuckets::update].
    fn update(
        &self,
        _req: crate::model::backend_buckets::UpdateRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::BackendBuckets::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::global_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::BackendServices].
///
/// Application developers may need to implement this trait to mock
/// `client::BackendServices`.  In other use-cases, application developers only
/// use `client::BackendServices` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "backend-services")]
#[cfg_attr(docsrs, doc(cfg(feature = "backend-services")))]
pub trait BackendServices: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::BackendServices::add_signed_url_key].
    fn add_signed_url_key(
        &self,
        _req: crate::model::backend_services::AddSignedUrlKeyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::BackendServices::aggregated_list].
    fn aggregated_list(
        &self,
        _req: crate::model::backend_services::AggregatedListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::BackendServiceAggregatedList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::BackendServices::delete].
    fn delete(
        &self,
        _req: crate::model::backend_services::DeleteRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::BackendServices::delete_signed_url_key].
    fn delete_signed_url_key(
        &self,
        _req: crate::model::backend_services::DeleteSignedUrlKeyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::BackendServices::get].
    fn get(
        &self,
        _req: crate::model::backend_services::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::BackendService>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::BackendServices::get_effective_security_policies].
    fn get_effective_security_policies(
        &self,
        _req: crate::model::backend_services::GetEffectiveSecurityPoliciesRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<Output = crate::Result<gax::response::Response<wkt::Empty>>> + Send
    {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::BackendServices::get_health].
    fn get_health(
        &self,
        _req: crate::model::backend_services::GetHealthRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::BackendServiceGroupHealth>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::BackendServices::get_iam_policy].
    fn get_iam_policy(
        &self,
        _req: crate::model::backend_services::GetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Policy>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::BackendServices::insert].
    fn insert(
        &self,
        _req: crate::model::backend_services::InsertRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::BackendServices::list].
    fn list(
        &self,
        _req: crate::model::backend_services::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::BackendServiceList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::BackendServices::list_usable].
    fn list_usable(
        &self,
        _req: crate::model::backend_services::ListUsableRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::BackendServiceListUsable>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::BackendServices::patch].
    fn patch(
        &self,
        _req: crate::model::backend_services::PatchRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::BackendServices::set_edge_security_policy].
    fn set_edge_security_policy(
        &self,
        _req: crate::model::backend_services::SetEdgeSecurityPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::BackendServices::set_iam_policy].
    fn set_iam_policy(
        &self,
        _req: crate::model::backend_services::SetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Policy>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::BackendServices::set_security_policy].
    fn set_security_policy(
        &self,
        _req: crate::model::backend_services::SetSecurityPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::BackendServices::test_iam_permissions].
    fn test_iam_permissions(
        &self,
        _req: crate::model::backend_services::TestIamPermissionsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::BackendServices::update].
    fn update(
        &self,
        _req: crate::model::backend_services::UpdateRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::BackendServices::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::global_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::CrossSiteNetworks].
///
/// Application developers may need to implement this trait to mock
/// `client::CrossSiteNetworks`.  In other use-cases, application developers only
/// use `client::CrossSiteNetworks` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "cross-site-networks")]
#[cfg_attr(docsrs, doc(cfg(feature = "cross-site-networks")))]
pub trait CrossSiteNetworks: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::CrossSiteNetworks::delete].
    fn delete(
        &self,
        _req: crate::model::cross_site_networks::DeleteRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::CrossSiteNetworks::get].
    fn get(
        &self,
        _req: crate::model::cross_site_networks::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::CrossSiteNetwork>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::CrossSiteNetworks::insert].
    fn insert(
        &self,
        _req: crate::model::cross_site_networks::InsertRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::CrossSiteNetworks::list].
    fn list(
        &self,
        _req: crate::model::cross_site_networks::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::CrossSiteNetworkList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::CrossSiteNetworks::patch].
    fn patch(
        &self,
        _req: crate::model::cross_site_networks::PatchRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::CrossSiteNetworks::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::global_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::DiskTypes].
///
/// Application developers may need to implement this trait to mock
/// `client::DiskTypes`.  In other use-cases, application developers only
/// use `client::DiskTypes` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "disk-types")]
#[cfg_attr(docsrs, doc(cfg(feature = "disk-types")))]
pub trait DiskTypes: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::DiskTypes::aggregated_list].
    fn aggregated_list(
        &self,
        _req: crate::model::disk_types::AggregatedListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::DiskTypeAggregatedList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::DiskTypes::get].
    fn get(
        &self,
        _req: crate::model::disk_types::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::DiskType>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::DiskTypes::list].
    fn list(
        &self,
        _req: crate::model::disk_types::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::DiskTypeList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }
}

/// Defines the trait used to implement [super::client::Disks].
///
/// Application developers may need to implement this trait to mock
/// `client::Disks`.  In other use-cases, application developers only
/// use `client::Disks` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "disks")]
#[cfg_attr(docsrs, doc(cfg(feature = "disks")))]
pub trait Disks: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::Disks::add_resource_policies].
    fn add_resource_policies(
        &self,
        _req: crate::model::disks::AddResourcePoliciesRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Disks::aggregated_list].
    fn aggregated_list(
        &self,
        _req: crate::model::disks::AggregatedListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::DiskAggregatedList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Disks::bulk_insert].
    fn bulk_insert(
        &self,
        _req: crate::model::disks::BulkInsertRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Disks::bulk_set_labels].
    fn bulk_set_labels(
        &self,
        _req: crate::model::disks::BulkSetLabelsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Disks::create_snapshot].
    fn create_snapshot(
        &self,
        _req: crate::model::disks::CreateSnapshotRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Disks::delete].
    fn delete(
        &self,
        _req: crate::model::disks::DeleteRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Disks::get].
    fn get(
        &self,
        _req: crate::model::disks::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Disk>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Disks::get_iam_policy].
    fn get_iam_policy(
        &self,
        _req: crate::model::disks::GetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Policy>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Disks::insert].
    fn insert(
        &self,
        _req: crate::model::disks::InsertRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Disks::list].
    fn list(
        &self,
        _req: crate::model::disks::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::DiskList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Disks::remove_resource_policies].
    fn remove_resource_policies(
        &self,
        _req: crate::model::disks::RemoveResourcePoliciesRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Disks::resize].
    fn resize(
        &self,
        _req: crate::model::disks::ResizeRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Disks::set_iam_policy].
    fn set_iam_policy(
        &self,
        _req: crate::model::disks::SetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Policy>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Disks::set_labels].
    fn set_labels(
        &self,
        _req: crate::model::disks::SetLabelsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Disks::start_async_replication].
    fn start_async_replication(
        &self,
        _req: crate::model::disks::StartAsyncReplicationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Disks::stop_async_replication].
    fn stop_async_replication(
        &self,
        _req: crate::model::disks::StopAsyncReplicationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Disks::stop_group_async_replication].
    fn stop_group_async_replication(
        &self,
        _req: crate::model::disks::StopGroupAsyncReplicationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Disks::test_iam_permissions].
    fn test_iam_permissions(
        &self,
        _req: crate::model::disks::TestIamPermissionsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Disks::update].
    fn update(
        &self,
        _req: crate::model::disks::UpdateRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Disks::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::zone_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::ExternalVpnGateways].
///
/// Application developers may need to implement this trait to mock
/// `client::ExternalVpnGateways`.  In other use-cases, application developers only
/// use `client::ExternalVpnGateways` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "external-vpn-gateways")]
#[cfg_attr(docsrs, doc(cfg(feature = "external-vpn-gateways")))]
pub trait ExternalVpnGateways: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::ExternalVpnGateways::delete].
    fn delete(
        &self,
        _req: crate::model::external_vpn_gateways::DeleteRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::ExternalVpnGateways::get].
    fn get(
        &self,
        _req: crate::model::external_vpn_gateways::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::ExternalVpnGateway>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::ExternalVpnGateways::insert].
    fn insert(
        &self,
        _req: crate::model::external_vpn_gateways::InsertRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::ExternalVpnGateways::list].
    fn list(
        &self,
        _req: crate::model::external_vpn_gateways::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::ExternalVpnGatewayList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::ExternalVpnGateways::set_labels].
    fn set_labels(
        &self,
        _req: crate::model::external_vpn_gateways::SetLabelsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::ExternalVpnGateways::test_iam_permissions].
    fn test_iam_permissions(
        &self,
        _req: crate::model::external_vpn_gateways::TestIamPermissionsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::ExternalVpnGateways::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::global_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::FirewallPolicies].
///
/// Application developers may need to implement this trait to mock
/// `client::FirewallPolicies`.  In other use-cases, application developers only
/// use `client::FirewallPolicies` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "firewall-policies")]
#[cfg_attr(docsrs, doc(cfg(feature = "firewall-policies")))]
pub trait FirewallPolicies: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::FirewallPolicies::add_association].
    fn add_association(
        &self,
        _req: crate::model::firewall_policies::AddAssociationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::FirewallPolicies::add_rule].
    fn add_rule(
        &self,
        _req: crate::model::firewall_policies::AddRuleRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::FirewallPolicies::clone_rules].
    fn clone_rules(
        &self,
        _req: crate::model::firewall_policies::CloneRulesRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::FirewallPolicies::delete].
    fn delete(
        &self,
        _req: crate::model::firewall_policies::DeleteRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::FirewallPolicies::get].
    fn get(
        &self,
        _req: crate::model::firewall_policies::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::FirewallPolicy>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::FirewallPolicies::get_association].
    fn get_association(
        &self,
        _req: crate::model::firewall_policies::GetAssociationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::FirewallPolicyAssociation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::FirewallPolicies::get_iam_policy].
    fn get_iam_policy(
        &self,
        _req: crate::model::firewall_policies::GetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Policy>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::FirewallPolicies::get_rule].
    fn get_rule(
        &self,
        _req: crate::model::firewall_policies::GetRuleRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::FirewallPolicyRule>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::FirewallPolicies::insert].
    fn insert(
        &self,
        _req: crate::model::firewall_policies::InsertRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::FirewallPolicies::list].
    fn list(
        &self,
        _req: crate::model::firewall_policies::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::FirewallPolicyList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::FirewallPolicies::list_associations].
    fn list_associations(
        &self,
        _req: crate::model::firewall_policies::ListAssociationsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<
            gax::response::Response<crate::model::FirewallPoliciesListAssociationsResponse>,
        >,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::FirewallPolicies::r#move].
    fn r#move(
        &self,
        _req: crate::model::firewall_policies::MoveRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::FirewallPolicies::patch].
    fn patch(
        &self,
        _req: crate::model::firewall_policies::PatchRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::FirewallPolicies::patch_rule].
    fn patch_rule(
        &self,
        _req: crate::model::firewall_policies::PatchRuleRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::FirewallPolicies::remove_association].
    fn remove_association(
        &self,
        _req: crate::model::firewall_policies::RemoveAssociationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::FirewallPolicies::remove_rule].
    fn remove_rule(
        &self,
        _req: crate::model::firewall_policies::RemoveRuleRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::FirewallPolicies::set_iam_policy].
    fn set_iam_policy(
        &self,
        _req: crate::model::firewall_policies::SetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Policy>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::FirewallPolicies::test_iam_permissions].
    fn test_iam_permissions(
        &self,
        _req: crate::model::firewall_policies::TestIamPermissionsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::FirewallPolicies::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::global_organization_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::Firewalls].
///
/// Application developers may need to implement this trait to mock
/// `client::Firewalls`.  In other use-cases, application developers only
/// use `client::Firewalls` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "firewalls")]
#[cfg_attr(docsrs, doc(cfg(feature = "firewalls")))]
pub trait Firewalls: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::Firewalls::delete].
    fn delete(
        &self,
        _req: crate::model::firewalls::DeleteRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Firewalls::get].
    fn get(
        &self,
        _req: crate::model::firewalls::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Firewall>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Firewalls::insert].
    fn insert(
        &self,
        _req: crate::model::firewalls::InsertRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Firewalls::list].
    fn list(
        &self,
        _req: crate::model::firewalls::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::FirewallList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Firewalls::patch].
    fn patch(
        &self,
        _req: crate::model::firewalls::PatchRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Firewalls::test_iam_permissions].
    fn test_iam_permissions(
        &self,
        _req: crate::model::firewalls::TestIamPermissionsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Firewalls::update].
    fn update(
        &self,
        _req: crate::model::firewalls::UpdateRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Firewalls::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::global_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::ForwardingRules].
///
/// Application developers may need to implement this trait to mock
/// `client::ForwardingRules`.  In other use-cases, application developers only
/// use `client::ForwardingRules` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "forwarding-rules")]
#[cfg_attr(docsrs, doc(cfg(feature = "forwarding-rules")))]
pub trait ForwardingRules: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::ForwardingRules::aggregated_list].
    fn aggregated_list(
        &self,
        _req: crate::model::forwarding_rules::AggregatedListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::ForwardingRuleAggregatedList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::ForwardingRules::delete].
    fn delete(
        &self,
        _req: crate::model::forwarding_rules::DeleteRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::ForwardingRules::get].
    fn get(
        &self,
        _req: crate::model::forwarding_rules::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::ForwardingRule>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::ForwardingRules::insert].
    fn insert(
        &self,
        _req: crate::model::forwarding_rules::InsertRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::ForwardingRules::list].
    fn list(
        &self,
        _req: crate::model::forwarding_rules::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::ForwardingRuleList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::ForwardingRules::patch].
    fn patch(
        &self,
        _req: crate::model::forwarding_rules::PatchRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::ForwardingRules::set_labels].
    fn set_labels(
        &self,
        _req: crate::model::forwarding_rules::SetLabelsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::ForwardingRules::set_target].
    fn set_target(
        &self,
        _req: crate::model::forwarding_rules::SetTargetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::ForwardingRules::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::region_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::FutureReservations].
///
/// Application developers may need to implement this trait to mock
/// `client::FutureReservations`.  In other use-cases, application developers only
/// use `client::FutureReservations` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "future-reservations")]
#[cfg_attr(docsrs, doc(cfg(feature = "future-reservations")))]
pub trait FutureReservations: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::FutureReservations::aggregated_list].
    fn aggregated_list(
        &self,
        _req: crate::model::future_reservations::AggregatedListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<
            gax::response::Response<crate::model::FutureReservationsAggregatedListResponse>,
        >,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::FutureReservations::cancel].
    fn cancel(
        &self,
        _req: crate::model::future_reservations::CancelRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::FutureReservations::delete].
    fn delete(
        &self,
        _req: crate::model::future_reservations::DeleteRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::FutureReservations::get].
    fn get(
        &self,
        _req: crate::model::future_reservations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::FutureReservation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::FutureReservations::insert].
    fn insert(
        &self,
        _req: crate::model::future_reservations::InsertRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::FutureReservations::list].
    fn list(
        &self,
        _req: crate::model::future_reservations::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<
            gax::response::Response<crate::model::FutureReservationsListResponse>,
        >,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::FutureReservations::update].
    fn update(
        &self,
        _req: crate::model::future_reservations::UpdateRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::FutureReservations::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::zone_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::GlobalAddresses].
///
/// Application developers may need to implement this trait to mock
/// `client::GlobalAddresses`.  In other use-cases, application developers only
/// use `client::GlobalAddresses` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "global-addresses")]
#[cfg_attr(docsrs, doc(cfg(feature = "global-addresses")))]
pub trait GlobalAddresses: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::GlobalAddresses::delete].
    fn delete(
        &self,
        _req: crate::model::global_addresses::DeleteRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::GlobalAddresses::get].
    fn get(
        &self,
        _req: crate::model::global_addresses::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Address>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::GlobalAddresses::insert].
    fn insert(
        &self,
        _req: crate::model::global_addresses::InsertRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::GlobalAddresses::list].
    fn list(
        &self,
        _req: crate::model::global_addresses::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::AddressList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::GlobalAddresses::r#move].
    fn r#move(
        &self,
        _req: crate::model::global_addresses::MoveRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::GlobalAddresses::set_labels].
    fn set_labels(
        &self,
        _req: crate::model::global_addresses::SetLabelsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::GlobalAddresses::test_iam_permissions].
    fn test_iam_permissions(
        &self,
        _req: crate::model::global_addresses::TestIamPermissionsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::GlobalAddresses::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::global_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::GlobalForwardingRules].
///
/// Application developers may need to implement this trait to mock
/// `client::GlobalForwardingRules`.  In other use-cases, application developers only
/// use `client::GlobalForwardingRules` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "global-forwarding-rules")]
#[cfg_attr(docsrs, doc(cfg(feature = "global-forwarding-rules")))]
pub trait GlobalForwardingRules: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::GlobalForwardingRules::delete].
    fn delete(
        &self,
        _req: crate::model::global_forwarding_rules::DeleteRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::GlobalForwardingRules::get].
    fn get(
        &self,
        _req: crate::model::global_forwarding_rules::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::ForwardingRule>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::GlobalForwardingRules::insert].
    fn insert(
        &self,
        _req: crate::model::global_forwarding_rules::InsertRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::GlobalForwardingRules::list].
    fn list(
        &self,
        _req: crate::model::global_forwarding_rules::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::ForwardingRuleList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::GlobalForwardingRules::patch].
    fn patch(
        &self,
        _req: crate::model::global_forwarding_rules::PatchRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::GlobalForwardingRules::set_labels].
    fn set_labels(
        &self,
        _req: crate::model::global_forwarding_rules::SetLabelsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::GlobalForwardingRules::set_target].
    fn set_target(
        &self,
        _req: crate::model::global_forwarding_rules::SetTargetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::GlobalForwardingRules::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::global_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::GlobalNetworkEndpointGroups].
///
/// Application developers may need to implement this trait to mock
/// `client::GlobalNetworkEndpointGroups`.  In other use-cases, application developers only
/// use `client::GlobalNetworkEndpointGroups` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "global-network-endpoint-groups")]
#[cfg_attr(docsrs, doc(cfg(feature = "global-network-endpoint-groups")))]
pub trait GlobalNetworkEndpointGroups: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::GlobalNetworkEndpointGroups::attach_network_endpoints].
    fn attach_network_endpoints(
        &self,
        _req: crate::model::global_network_endpoint_groups::AttachNetworkEndpointsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::GlobalNetworkEndpointGroups::delete].
    fn delete(
        &self,
        _req: crate::model::global_network_endpoint_groups::DeleteRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::GlobalNetworkEndpointGroups::detach_network_endpoints].
    fn detach_network_endpoints(
        &self,
        _req: crate::model::global_network_endpoint_groups::DetachNetworkEndpointsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::GlobalNetworkEndpointGroups::get].
    fn get(
        &self,
        _req: crate::model::global_network_endpoint_groups::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::NetworkEndpointGroup>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::GlobalNetworkEndpointGroups::insert].
    fn insert(
        &self,
        _req: crate::model::global_network_endpoint_groups::InsertRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::GlobalNetworkEndpointGroups::list].
    fn list(
        &self,
        _req: crate::model::global_network_endpoint_groups::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::NetworkEndpointGroupList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::GlobalNetworkEndpointGroups::list_network_endpoints].
    fn list_network_endpoints(
        &self,
        _req: crate::model::global_network_endpoint_groups::ListNetworkEndpointsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<
            gax::response::Response<crate::model::NetworkEndpointGroupsListNetworkEndpoints>,
        >,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::GlobalNetworkEndpointGroups::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::global_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::GlobalOperations].
///
/// Application developers may need to implement this trait to mock
/// `client::GlobalOperations`.  In other use-cases, application developers only
/// use `client::GlobalOperations` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "global-operations")]
#[cfg_attr(docsrs, doc(cfg(feature = "global-operations")))]
pub trait GlobalOperations: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::GlobalOperations::aggregated_list].
    fn aggregated_list(
        &self,
        _req: crate::model::global_operations::AggregatedListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::OperationAggregatedList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::GlobalOperations::delete].
    fn delete(
        &self,
        _req: crate::model::global_operations::DeleteRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<Output = crate::Result<gax::response::Response<wkt::Empty>>> + Send
    {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::GlobalOperations::get].
    fn get(
        &self,
        _req: crate::model::global_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::GlobalOperations::list].
    fn list(
        &self,
        _req: crate::model::global_operations::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::OperationList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::GlobalOperations::wait].
    fn wait(
        &self,
        _req: crate::model::global_operations::WaitRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }
}

/// Defines the trait used to implement [super::client::GlobalOrganizationOperations].
///
/// Application developers may need to implement this trait to mock
/// `client::GlobalOrganizationOperations`.  In other use-cases, application developers only
/// use `client::GlobalOrganizationOperations` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "global-organization-operations")]
#[cfg_attr(docsrs, doc(cfg(feature = "global-organization-operations")))]
pub trait GlobalOrganizationOperations: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::GlobalOrganizationOperations::delete].
    fn delete(
        &self,
        _req: crate::model::global_organization_operations::DeleteRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<Output = crate::Result<gax::response::Response<wkt::Empty>>> + Send
    {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::GlobalOrganizationOperations::get].
    fn get(
        &self,
        _req: crate::model::global_organization_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::GlobalOrganizationOperations::list].
    fn list(
        &self,
        _req: crate::model::global_organization_operations::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::OperationList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }
}

/// Defines the trait used to implement [super::client::GlobalPublicDelegatedPrefixes].
///
/// Application developers may need to implement this trait to mock
/// `client::GlobalPublicDelegatedPrefixes`.  In other use-cases, application developers only
/// use `client::GlobalPublicDelegatedPrefixes` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "global-public-delegated-prefixes")]
#[cfg_attr(docsrs, doc(cfg(feature = "global-public-delegated-prefixes")))]
pub trait GlobalPublicDelegatedPrefixes: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::GlobalPublicDelegatedPrefixes::delete].
    fn delete(
        &self,
        _req: crate::model::global_public_delegated_prefixes::DeleteRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::GlobalPublicDelegatedPrefixes::get].
    fn get(
        &self,
        _req: crate::model::global_public_delegated_prefixes::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::PublicDelegatedPrefix>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::GlobalPublicDelegatedPrefixes::insert].
    fn insert(
        &self,
        _req: crate::model::global_public_delegated_prefixes::InsertRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::GlobalPublicDelegatedPrefixes::list].
    fn list(
        &self,
        _req: crate::model::global_public_delegated_prefixes::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::PublicDelegatedPrefixList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::GlobalPublicDelegatedPrefixes::patch].
    fn patch(
        &self,
        _req: crate::model::global_public_delegated_prefixes::PatchRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::GlobalPublicDelegatedPrefixes::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::global_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::HealthChecks].
///
/// Application developers may need to implement this trait to mock
/// `client::HealthChecks`.  In other use-cases, application developers only
/// use `client::HealthChecks` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "health-checks")]
#[cfg_attr(docsrs, doc(cfg(feature = "health-checks")))]
pub trait HealthChecks: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::HealthChecks::aggregated_list].
    fn aggregated_list(
        &self,
        _req: crate::model::health_checks::AggregatedListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::HealthChecksAggregatedList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::HealthChecks::delete].
    fn delete(
        &self,
        _req: crate::model::health_checks::DeleteRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::HealthChecks::get].
    fn get(
        &self,
        _req: crate::model::health_checks::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::HealthCheck>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::HealthChecks::insert].
    fn insert(
        &self,
        _req: crate::model::health_checks::InsertRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::HealthChecks::list].
    fn list(
        &self,
        _req: crate::model::health_checks::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::HealthCheckList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::HealthChecks::patch].
    fn patch(
        &self,
        _req: crate::model::health_checks::PatchRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::HealthChecks::update].
    fn update(
        &self,
        _req: crate::model::health_checks::UpdateRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::HealthChecks::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::global_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::HttpHealthChecks].
///
/// Application developers may need to implement this trait to mock
/// `client::HttpHealthChecks`.  In other use-cases, application developers only
/// use `client::HttpHealthChecks` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "http-health-checks")]
#[cfg_attr(docsrs, doc(cfg(feature = "http-health-checks")))]
pub trait HttpHealthChecks: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::HttpHealthChecks::delete].
    fn delete(
        &self,
        _req: crate::model::http_health_checks::DeleteRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::HttpHealthChecks::get].
    fn get(
        &self,
        _req: crate::model::http_health_checks::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::HttpHealthCheck>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::HttpHealthChecks::insert].
    fn insert(
        &self,
        _req: crate::model::http_health_checks::InsertRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::HttpHealthChecks::list].
    fn list(
        &self,
        _req: crate::model::http_health_checks::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::HttpHealthCheckList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::HttpHealthChecks::patch].
    fn patch(
        &self,
        _req: crate::model::http_health_checks::PatchRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::HttpHealthChecks::update].
    fn update(
        &self,
        _req: crate::model::http_health_checks::UpdateRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::HttpHealthChecks::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::global_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::HttpsHealthChecks].
///
/// Application developers may need to implement this trait to mock
/// `client::HttpsHealthChecks`.  In other use-cases, application developers only
/// use `client::HttpsHealthChecks` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "https-health-checks")]
#[cfg_attr(docsrs, doc(cfg(feature = "https-health-checks")))]
pub trait HttpsHealthChecks: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::HttpsHealthChecks::delete].
    fn delete(
        &self,
        _req: crate::model::https_health_checks::DeleteRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::HttpsHealthChecks::get].
    fn get(
        &self,
        _req: crate::model::https_health_checks::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::HttpsHealthCheck>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::HttpsHealthChecks::insert].
    fn insert(
        &self,
        _req: crate::model::https_health_checks::InsertRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::HttpsHealthChecks::list].
    fn list(
        &self,
        _req: crate::model::https_health_checks::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::HttpsHealthCheckList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::HttpsHealthChecks::patch].
    fn patch(
        &self,
        _req: crate::model::https_health_checks::PatchRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::HttpsHealthChecks::update].
    fn update(
        &self,
        _req: crate::model::https_health_checks::UpdateRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::HttpsHealthChecks::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::global_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::ImageFamilyViews].
///
/// Application developers may need to implement this trait to mock
/// `client::ImageFamilyViews`.  In other use-cases, application developers only
/// use `client::ImageFamilyViews` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "image-family-views")]
#[cfg_attr(docsrs, doc(cfg(feature = "image-family-views")))]
pub trait ImageFamilyViews: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::ImageFamilyViews::get].
    fn get(
        &self,
        _req: crate::model::image_family_views::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::ImageFamilyView>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }
}

/// Defines the trait used to implement [super::client::Images].
///
/// Application developers may need to implement this trait to mock
/// `client::Images`.  In other use-cases, application developers only
/// use `client::Images` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "images")]
#[cfg_attr(docsrs, doc(cfg(feature = "images")))]
pub trait Images: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::Images::delete].
    fn delete(
        &self,
        _req: crate::model::images::DeleteRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Images::deprecate].
    fn deprecate(
        &self,
        _req: crate::model::images::DeprecateRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Images::get].
    fn get(
        &self,
        _req: crate::model::images::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Image>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Images::get_from_family].
    fn get_from_family(
        &self,
        _req: crate::model::images::GetFromFamilyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Image>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Images::get_iam_policy].
    fn get_iam_policy(
        &self,
        _req: crate::model::images::GetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Policy>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Images::insert].
    fn insert(
        &self,
        _req: crate::model::images::InsertRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Images::list].
    fn list(
        &self,
        _req: crate::model::images::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::ImageList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Images::patch].
    fn patch(
        &self,
        _req: crate::model::images::PatchRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Images::set_iam_policy].
    fn set_iam_policy(
        &self,
        _req: crate::model::images::SetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Policy>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Images::set_labels].
    fn set_labels(
        &self,
        _req: crate::model::images::SetLabelsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Images::test_iam_permissions].
    fn test_iam_permissions(
        &self,
        _req: crate::model::images::TestIamPermissionsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Images::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::global_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::InstanceGroupManagerResizeRequests].
///
/// Application developers may need to implement this trait to mock
/// `client::InstanceGroupManagerResizeRequests`.  In other use-cases, application developers only
/// use `client::InstanceGroupManagerResizeRequests` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "instance-group-manager-resize-requests")]
#[cfg_attr(docsrs, doc(cfg(feature = "instance-group-manager-resize-requests")))]
pub trait InstanceGroupManagerResizeRequests: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::InstanceGroupManagerResizeRequests::cancel].
    fn cancel(
        &self,
        _req: crate::model::instance_group_manager_resize_requests::CancelRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::InstanceGroupManagerResizeRequests::delete].
    fn delete(
        &self,
        _req: crate::model::instance_group_manager_resize_requests::DeleteRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::InstanceGroupManagerResizeRequests::get].
    fn get(
        &self,
        _req: crate::model::instance_group_manager_resize_requests::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<
            gax::response::Response<crate::model::InstanceGroupManagerResizeRequest>,
        >,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::InstanceGroupManagerResizeRequests::insert].
    fn insert(
        &self,
        _req: crate::model::instance_group_manager_resize_requests::InsertRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::InstanceGroupManagerResizeRequests::list].
    fn list(
        &self,
        _req: crate::model::instance_group_manager_resize_requests::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<
            gax::response::Response<crate::model::InstanceGroupManagerResizeRequestsListResponse>,
        >,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::InstanceGroupManagerResizeRequests::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::zone_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::InstanceGroupManagers].
///
/// Application developers may need to implement this trait to mock
/// `client::InstanceGroupManagers`.  In other use-cases, application developers only
/// use `client::InstanceGroupManagers` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "instance-group-managers")]
#[cfg_attr(docsrs, doc(cfg(feature = "instance-group-managers")))]
pub trait InstanceGroupManagers: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::InstanceGroupManagers::abandon_instances].
    fn abandon_instances(
        &self,
        _req: crate::model::instance_group_managers::AbandonInstancesRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::InstanceGroupManagers::aggregated_list].
    fn aggregated_list(
        &self,
        _req: crate::model::instance_group_managers::AggregatedListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<
            gax::response::Response<crate::model::InstanceGroupManagerAggregatedList>,
        >,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::InstanceGroupManagers::apply_updates_to_instances].
    fn apply_updates_to_instances(
        &self,
        _req: crate::model::instance_group_managers::ApplyUpdatesToInstancesRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::InstanceGroupManagers::create_instances].
    fn create_instances(
        &self,
        _req: crate::model::instance_group_managers::CreateInstancesRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::InstanceGroupManagers::delete].
    fn delete(
        &self,
        _req: crate::model::instance_group_managers::DeleteRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::InstanceGroupManagers::delete_instances].
    fn delete_instances(
        &self,
        _req: crate::model::instance_group_managers::DeleteInstancesRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::InstanceGroupManagers::delete_per_instance_configs].
    fn delete_per_instance_configs(
        &self,
        _req: crate::model::instance_group_managers::DeletePerInstanceConfigsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::InstanceGroupManagers::get].
    fn get(
        &self,
        _req: crate::model::instance_group_managers::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::InstanceGroupManager>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::InstanceGroupManagers::insert].
    fn insert(
        &self,
        _req: crate::model::instance_group_managers::InsertRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::InstanceGroupManagers::list].
    fn list(
        &self,
        _req: crate::model::instance_group_managers::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::InstanceGroupManagerList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::InstanceGroupManagers::list_errors].
    fn list_errors(
        &self,
        _req: crate::model::instance_group_managers::ListErrorsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<
            gax::response::Response<crate::model::InstanceGroupManagersListErrorsResponse>,
        >,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::InstanceGroupManagers::list_managed_instances].
    fn list_managed_instances(
        &self,
        _req: crate::model::instance_group_managers::ListManagedInstancesRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<
            gax::response::Response<
                crate::model::InstanceGroupManagersListManagedInstancesResponse,
            >,
        >,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::InstanceGroupManagers::list_per_instance_configs].
    fn list_per_instance_configs(
        &self,
        _req: crate::model::instance_group_managers::ListPerInstanceConfigsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<
            gax::response::Response<crate::model::InstanceGroupManagersListPerInstanceConfigsResp>,
        >,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::InstanceGroupManagers::patch].
    fn patch(
        &self,
        _req: crate::model::instance_group_managers::PatchRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::InstanceGroupManagers::patch_per_instance_configs].
    fn patch_per_instance_configs(
        &self,
        _req: crate::model::instance_group_managers::PatchPerInstanceConfigsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::InstanceGroupManagers::recreate_instances].
    fn recreate_instances(
        &self,
        _req: crate::model::instance_group_managers::RecreateInstancesRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::InstanceGroupManagers::resize].
    fn resize(
        &self,
        _req: crate::model::instance_group_managers::ResizeRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::InstanceGroupManagers::resume_instances].
    fn resume_instances(
        &self,
        _req: crate::model::instance_group_managers::ResumeInstancesRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::InstanceGroupManagers::set_instance_template].
    fn set_instance_template(
        &self,
        _req: crate::model::instance_group_managers::SetInstanceTemplateRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::InstanceGroupManagers::set_target_pools].
    fn set_target_pools(
        &self,
        _req: crate::model::instance_group_managers::SetTargetPoolsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::InstanceGroupManagers::start_instances].
    fn start_instances(
        &self,
        _req: crate::model::instance_group_managers::StartInstancesRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::InstanceGroupManagers::stop_instances].
    fn stop_instances(
        &self,
        _req: crate::model::instance_group_managers::StopInstancesRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::InstanceGroupManagers::suspend_instances].
    fn suspend_instances(
        &self,
        _req: crate::model::instance_group_managers::SuspendInstancesRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::InstanceGroupManagers::update_per_instance_configs].
    fn update_per_instance_configs(
        &self,
        _req: crate::model::instance_group_managers::UpdatePerInstanceConfigsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::InstanceGroupManagers::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::zone_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::InstanceGroups].
///
/// Application developers may need to implement this trait to mock
/// `client::InstanceGroups`.  In other use-cases, application developers only
/// use `client::InstanceGroups` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "instance-groups")]
#[cfg_attr(docsrs, doc(cfg(feature = "instance-groups")))]
pub trait InstanceGroups: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::InstanceGroups::add_instances].
    fn add_instances(
        &self,
        _req: crate::model::instance_groups::AddInstancesRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::InstanceGroups::aggregated_list].
    fn aggregated_list(
        &self,
        _req: crate::model::instance_groups::AggregatedListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::InstanceGroupAggregatedList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::InstanceGroups::delete].
    fn delete(
        &self,
        _req: crate::model::instance_groups::DeleteRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::InstanceGroups::get].
    fn get(
        &self,
        _req: crate::model::instance_groups::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::InstanceGroup>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::InstanceGroups::insert].
    fn insert(
        &self,
        _req: crate::model::instance_groups::InsertRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::InstanceGroups::list].
    fn list(
        &self,
        _req: crate::model::instance_groups::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::InstanceGroupList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::InstanceGroups::list_instances].
    fn list_instances(
        &self,
        _req: crate::model::instance_groups::ListInstancesRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::InstanceGroupsListInstances>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::InstanceGroups::remove_instances].
    fn remove_instances(
        &self,
        _req: crate::model::instance_groups::RemoveInstancesRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::InstanceGroups::set_named_ports].
    fn set_named_ports(
        &self,
        _req: crate::model::instance_groups::SetNamedPortsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::InstanceGroups::test_iam_permissions].
    fn test_iam_permissions(
        &self,
        _req: crate::model::instance_groups::TestIamPermissionsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::InstanceGroups::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::zone_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::InstanceSettings].
///
/// Application developers may need to implement this trait to mock
/// `client::InstanceSettings`.  In other use-cases, application developers only
/// use `client::InstanceSettings` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "instance-settings")]
#[cfg_attr(docsrs, doc(cfg(feature = "instance-settings")))]
pub trait InstanceSettings: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::InstanceSettings::get].
    fn get(
        &self,
        _req: crate::model::instance_settings::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::InstanceSettings>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::InstanceSettings::patch].
    fn patch(
        &self,
        _req: crate::model::instance_settings::PatchRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::InstanceSettings::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::zone_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::InstanceTemplates].
///
/// Application developers may need to implement this trait to mock
/// `client::InstanceTemplates`.  In other use-cases, application developers only
/// use `client::InstanceTemplates` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "instance-templates")]
#[cfg_attr(docsrs, doc(cfg(feature = "instance-templates")))]
pub trait InstanceTemplates: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::InstanceTemplates::aggregated_list].
    fn aggregated_list(
        &self,
        _req: crate::model::instance_templates::AggregatedListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<
            gax::response::Response<crate::model::InstanceTemplateAggregatedList>,
        >,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::InstanceTemplates::delete].
    fn delete(
        &self,
        _req: crate::model::instance_templates::DeleteRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::InstanceTemplates::get].
    fn get(
        &self,
        _req: crate::model::instance_templates::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::InstanceTemplate>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::InstanceTemplates::get_iam_policy].
    fn get_iam_policy(
        &self,
        _req: crate::model::instance_templates::GetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Policy>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::InstanceTemplates::insert].
    fn insert(
        &self,
        _req: crate::model::instance_templates::InsertRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::InstanceTemplates::list].
    fn list(
        &self,
        _req: crate::model::instance_templates::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::InstanceTemplateList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::InstanceTemplates::set_iam_policy].
    fn set_iam_policy(
        &self,
        _req: crate::model::instance_templates::SetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Policy>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::InstanceTemplates::test_iam_permissions].
    fn test_iam_permissions(
        &self,
        _req: crate::model::instance_templates::TestIamPermissionsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::InstanceTemplates::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::global_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::Instances].
///
/// Application developers may need to implement this trait to mock
/// `client::Instances`.  In other use-cases, application developers only
/// use `client::Instances` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "instances")]
#[cfg_attr(docsrs, doc(cfg(feature = "instances")))]
pub trait Instances: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::Instances::add_access_config].
    fn add_access_config(
        &self,
        _req: crate::model::instances::AddAccessConfigRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Instances::add_network_interface].
    fn add_network_interface(
        &self,
        _req: crate::model::instances::AddNetworkInterfaceRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Instances::add_resource_policies].
    fn add_resource_policies(
        &self,
        _req: crate::model::instances::AddResourcePoliciesRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Instances::aggregated_list].
    fn aggregated_list(
        &self,
        _req: crate::model::instances::AggregatedListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::InstanceAggregatedList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Instances::attach_disk].
    fn attach_disk(
        &self,
        _req: crate::model::instances::AttachDiskRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Instances::bulk_insert].
    fn bulk_insert(
        &self,
        _req: crate::model::instances::BulkInsertRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Instances::delete].
    fn delete(
        &self,
        _req: crate::model::instances::DeleteRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Instances::delete_access_config].
    fn delete_access_config(
        &self,
        _req: crate::model::instances::DeleteAccessConfigRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Instances::delete_network_interface].
    fn delete_network_interface(
        &self,
        _req: crate::model::instances::DeleteNetworkInterfaceRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Instances::detach_disk].
    fn detach_disk(
        &self,
        _req: crate::model::instances::DetachDiskRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Instances::get].
    fn get(
        &self,
        _req: crate::model::instances::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Instance>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Instances::get_effective_firewalls].
    fn get_effective_firewalls(
        &self,
        _req: crate::model::instances::GetEffectiveFirewallsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<
            gax::response::Response<crate::model::InstancesGetEffectiveFirewallsResponse>,
        >,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Instances::get_guest_attributes].
    fn get_guest_attributes(
        &self,
        _req: crate::model::instances::GetGuestAttributesRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::GuestAttributes>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Instances::get_iam_policy].
    fn get_iam_policy(
        &self,
        _req: crate::model::instances::GetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Policy>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Instances::get_screenshot].
    fn get_screenshot(
        &self,
        _req: crate::model::instances::GetScreenshotRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Screenshot>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Instances::get_serial_port_output].
    fn get_serial_port_output(
        &self,
        _req: crate::model::instances::GetSerialPortOutputRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::SerialPortOutput>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Instances::get_shielded_instance_identity].
    fn get_shielded_instance_identity(
        &self,
        _req: crate::model::instances::GetShieldedInstanceIdentityRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::ShieldedInstanceIdentity>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Instances::insert].
    fn insert(
        &self,
        _req: crate::model::instances::InsertRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Instances::list].
    fn list(
        &self,
        _req: crate::model::instances::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::InstanceList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Instances::list_referrers].
    fn list_referrers(
        &self,
        _req: crate::model::instances::ListReferrersRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::InstanceListReferrers>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Instances::perform_maintenance].
    fn perform_maintenance(
        &self,
        _req: crate::model::instances::PerformMaintenanceRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Instances::remove_resource_policies].
    fn remove_resource_policies(
        &self,
        _req: crate::model::instances::RemoveResourcePoliciesRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Instances::report_host_as_faulty].
    fn report_host_as_faulty(
        &self,
        _req: crate::model::instances::ReportHostAsFaultyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Instances::reset].
    fn reset(
        &self,
        _req: crate::model::instances::ResetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Instances::resume].
    fn resume(
        &self,
        _req: crate::model::instances::ResumeRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Instances::send_diagnostic_interrupt].
    fn send_diagnostic_interrupt(
        &self,
        _req: crate::model::instances::SendDiagnosticInterruptRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<Output = crate::Result<gax::response::Response<wkt::Empty>>> + Send
    {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Instances::set_deletion_protection].
    fn set_deletion_protection(
        &self,
        _req: crate::model::instances::SetDeletionProtectionRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Instances::set_disk_auto_delete].
    fn set_disk_auto_delete(
        &self,
        _req: crate::model::instances::SetDiskAutoDeleteRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Instances::set_iam_policy].
    fn set_iam_policy(
        &self,
        _req: crate::model::instances::SetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Policy>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Instances::set_labels].
    fn set_labels(
        &self,
        _req: crate::model::instances::SetLabelsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Instances::set_machine_resources].
    fn set_machine_resources(
        &self,
        _req: crate::model::instances::SetMachineResourcesRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Instances::set_machine_type].
    fn set_machine_type(
        &self,
        _req: crate::model::instances::SetMachineTypeRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Instances::set_metadata].
    fn set_metadata(
        &self,
        _req: crate::model::instances::SetMetadataRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Instances::set_min_cpu_platform].
    fn set_min_cpu_platform(
        &self,
        _req: crate::model::instances::SetMinCpuPlatformRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Instances::set_name].
    fn set_name(
        &self,
        _req: crate::model::instances::SetNameRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Instances::set_scheduling].
    fn set_scheduling(
        &self,
        _req: crate::model::instances::SetSchedulingRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Instances::set_security_policy].
    fn set_security_policy(
        &self,
        _req: crate::model::instances::SetSecurityPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Instances::set_service_account].
    fn set_service_account(
        &self,
        _req: crate::model::instances::SetServiceAccountRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Instances::set_shielded_instance_integrity_policy].
    fn set_shielded_instance_integrity_policy(
        &self,
        _req: crate::model::instances::SetShieldedInstanceIntegrityPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Instances::set_tags].
    fn set_tags(
        &self,
        _req: crate::model::instances::SetTagsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Instances::simulate_maintenance_event].
    fn simulate_maintenance_event(
        &self,
        _req: crate::model::instances::SimulateMaintenanceEventRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Instances::start].
    fn start(
        &self,
        _req: crate::model::instances::StartRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Instances::start_with_encryption_key].
    fn start_with_encryption_key(
        &self,
        _req: crate::model::instances::StartWithEncryptionKeyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Instances::stop].
    fn stop(
        &self,
        _req: crate::model::instances::StopRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Instances::suspend].
    fn suspend(
        &self,
        _req: crate::model::instances::SuspendRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Instances::test_iam_permissions].
    fn test_iam_permissions(
        &self,
        _req: crate::model::instances::TestIamPermissionsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Instances::update].
    fn update(
        &self,
        _req: crate::model::instances::UpdateRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Instances::update_access_config].
    fn update_access_config(
        &self,
        _req: crate::model::instances::UpdateAccessConfigRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Instances::update_display_device].
    fn update_display_device(
        &self,
        _req: crate::model::instances::UpdateDisplayDeviceRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Instances::update_network_interface].
    fn update_network_interface(
        &self,
        _req: crate::model::instances::UpdateNetworkInterfaceRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Instances::update_shielded_instance_config].
    fn update_shielded_instance_config(
        &self,
        _req: crate::model::instances::UpdateShieldedInstanceConfigRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Instances::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::zone_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::InstantSnapshots].
///
/// Application developers may need to implement this trait to mock
/// `client::InstantSnapshots`.  In other use-cases, application developers only
/// use `client::InstantSnapshots` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "instant-snapshots")]
#[cfg_attr(docsrs, doc(cfg(feature = "instant-snapshots")))]
pub trait InstantSnapshots: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::InstantSnapshots::aggregated_list].
    fn aggregated_list(
        &self,
        _req: crate::model::instant_snapshots::AggregatedListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<
            gax::response::Response<crate::model::InstantSnapshotAggregatedList>,
        >,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::InstantSnapshots::delete].
    fn delete(
        &self,
        _req: crate::model::instant_snapshots::DeleteRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::InstantSnapshots::get].
    fn get(
        &self,
        _req: crate::model::instant_snapshots::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::InstantSnapshot>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::InstantSnapshots::get_iam_policy].
    fn get_iam_policy(
        &self,
        _req: crate::model::instant_snapshots::GetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Policy>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::InstantSnapshots::insert].
    fn insert(
        &self,
        _req: crate::model::instant_snapshots::InsertRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::InstantSnapshots::list].
    fn list(
        &self,
        _req: crate::model::instant_snapshots::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::InstantSnapshotList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::InstantSnapshots::set_iam_policy].
    fn set_iam_policy(
        &self,
        _req: crate::model::instant_snapshots::SetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Policy>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::InstantSnapshots::set_labels].
    fn set_labels(
        &self,
        _req: crate::model::instant_snapshots::SetLabelsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::InstantSnapshots::test_iam_permissions].
    fn test_iam_permissions(
        &self,
        _req: crate::model::instant_snapshots::TestIamPermissionsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::InstantSnapshots::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::zone_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::InterconnectAttachmentGroups].
///
/// Application developers may need to implement this trait to mock
/// `client::InterconnectAttachmentGroups`.  In other use-cases, application developers only
/// use `client::InterconnectAttachmentGroups` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "interconnect-attachment-groups")]
#[cfg_attr(docsrs, doc(cfg(feature = "interconnect-attachment-groups")))]
pub trait InterconnectAttachmentGroups: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::InterconnectAttachmentGroups::delete].
    fn delete(
        &self,
        _req: crate::model::interconnect_attachment_groups::DeleteRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::InterconnectAttachmentGroups::get].
    fn get(
        &self,
        _req: crate::model::interconnect_attachment_groups::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::InterconnectAttachmentGroup>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::InterconnectAttachmentGroups::get_iam_policy].
    fn get_iam_policy(
        &self,
        _req: crate::model::interconnect_attachment_groups::GetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Policy>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::InterconnectAttachmentGroups::get_operational_status].
    fn get_operational_status(
        &self,
        _req: crate::model::interconnect_attachment_groups::GetOperationalStatusRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<
            gax::response::Response<
                crate::model::InterconnectAttachmentGroupsGetOperationalStatusResponse,
            >,
        >,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::InterconnectAttachmentGroups::insert].
    fn insert(
        &self,
        _req: crate::model::interconnect_attachment_groups::InsertRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::InterconnectAttachmentGroups::list].
    fn list(
        &self,
        _req: crate::model::interconnect_attachment_groups::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<
            gax::response::Response<crate::model::InterconnectAttachmentGroupsListResponse>,
        >,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::InterconnectAttachmentGroups::patch].
    fn patch(
        &self,
        _req: crate::model::interconnect_attachment_groups::PatchRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::InterconnectAttachmentGroups::set_iam_policy].
    fn set_iam_policy(
        &self,
        _req: crate::model::interconnect_attachment_groups::SetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Policy>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::InterconnectAttachmentGroups::test_iam_permissions].
    fn test_iam_permissions(
        &self,
        _req: crate::model::interconnect_attachment_groups::TestIamPermissionsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::InterconnectAttachmentGroups::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::global_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::InterconnectAttachments].
///
/// Application developers may need to implement this trait to mock
/// `client::InterconnectAttachments`.  In other use-cases, application developers only
/// use `client::InterconnectAttachments` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "interconnect-attachments")]
#[cfg_attr(docsrs, doc(cfg(feature = "interconnect-attachments")))]
pub trait InterconnectAttachments: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::InterconnectAttachments::aggregated_list].
    fn aggregated_list(
        &self,
        _req: crate::model::interconnect_attachments::AggregatedListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<
            gax::response::Response<crate::model::InterconnectAttachmentAggregatedList>,
        >,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::InterconnectAttachments::delete].
    fn delete(
        &self,
        _req: crate::model::interconnect_attachments::DeleteRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::InterconnectAttachments::get].
    fn get(
        &self,
        _req: crate::model::interconnect_attachments::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::InterconnectAttachment>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::InterconnectAttachments::insert].
    fn insert(
        &self,
        _req: crate::model::interconnect_attachments::InsertRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::InterconnectAttachments::list].
    fn list(
        &self,
        _req: crate::model::interconnect_attachments::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::InterconnectAttachmentList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::InterconnectAttachments::patch].
    fn patch(
        &self,
        _req: crate::model::interconnect_attachments::PatchRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::InterconnectAttachments::set_labels].
    fn set_labels(
        &self,
        _req: crate::model::interconnect_attachments::SetLabelsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::InterconnectAttachments::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::region_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::InterconnectGroups].
///
/// Application developers may need to implement this trait to mock
/// `client::InterconnectGroups`.  In other use-cases, application developers only
/// use `client::InterconnectGroups` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "interconnect-groups")]
#[cfg_attr(docsrs, doc(cfg(feature = "interconnect-groups")))]
pub trait InterconnectGroups: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::InterconnectGroups::create_members].
    fn create_members(
        &self,
        _req: crate::model::interconnect_groups::CreateMembersRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::InterconnectGroups::delete].
    fn delete(
        &self,
        _req: crate::model::interconnect_groups::DeleteRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::InterconnectGroups::get].
    fn get(
        &self,
        _req: crate::model::interconnect_groups::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::InterconnectGroup>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::InterconnectGroups::get_iam_policy].
    fn get_iam_policy(
        &self,
        _req: crate::model::interconnect_groups::GetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Policy>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::InterconnectGroups::get_operational_status].
    fn get_operational_status(
        &self,
        _req: crate::model::interconnect_groups::GetOperationalStatusRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<
            gax::response::Response<crate::model::InterconnectGroupsGetOperationalStatusResponse>,
        >,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::InterconnectGroups::insert].
    fn insert(
        &self,
        _req: crate::model::interconnect_groups::InsertRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::InterconnectGroups::list].
    fn list(
        &self,
        _req: crate::model::interconnect_groups::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<
            gax::response::Response<crate::model::InterconnectGroupsListResponse>,
        >,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::InterconnectGroups::patch].
    fn patch(
        &self,
        _req: crate::model::interconnect_groups::PatchRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::InterconnectGroups::set_iam_policy].
    fn set_iam_policy(
        &self,
        _req: crate::model::interconnect_groups::SetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Policy>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::InterconnectGroups::test_iam_permissions].
    fn test_iam_permissions(
        &self,
        _req: crate::model::interconnect_groups::TestIamPermissionsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::InterconnectGroups::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::global_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::InterconnectLocations].
///
/// Application developers may need to implement this trait to mock
/// `client::InterconnectLocations`.  In other use-cases, application developers only
/// use `client::InterconnectLocations` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "interconnect-locations")]
#[cfg_attr(docsrs, doc(cfg(feature = "interconnect-locations")))]
pub trait InterconnectLocations: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::InterconnectLocations::get].
    fn get(
        &self,
        _req: crate::model::interconnect_locations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::InterconnectLocation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::InterconnectLocations::list].
    fn list(
        &self,
        _req: crate::model::interconnect_locations::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::InterconnectLocationList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }
}

/// Defines the trait used to implement [super::client::InterconnectRemoteLocations].
///
/// Application developers may need to implement this trait to mock
/// `client::InterconnectRemoteLocations`.  In other use-cases, application developers only
/// use `client::InterconnectRemoteLocations` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "interconnect-remote-locations")]
#[cfg_attr(docsrs, doc(cfg(feature = "interconnect-remote-locations")))]
pub trait InterconnectRemoteLocations: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::InterconnectRemoteLocations::get].
    fn get(
        &self,
        _req: crate::model::interconnect_remote_locations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::InterconnectRemoteLocation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::InterconnectRemoteLocations::list].
    fn list(
        &self,
        _req: crate::model::interconnect_remote_locations::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<
            gax::response::Response<crate::model::InterconnectRemoteLocationList>,
        >,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }
}

/// Defines the trait used to implement [super::client::Interconnects].
///
/// Application developers may need to implement this trait to mock
/// `client::Interconnects`.  In other use-cases, application developers only
/// use `client::Interconnects` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "interconnects")]
#[cfg_attr(docsrs, doc(cfg(feature = "interconnects")))]
pub trait Interconnects: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::Interconnects::delete].
    fn delete(
        &self,
        _req: crate::model::interconnects::DeleteRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Interconnects::get].
    fn get(
        &self,
        _req: crate::model::interconnects::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Interconnect>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Interconnects::get_diagnostics].
    fn get_diagnostics(
        &self,
        _req: crate::model::interconnects::GetDiagnosticsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<
            gax::response::Response<crate::model::InterconnectsGetDiagnosticsResponse>,
        >,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Interconnects::get_macsec_config].
    fn get_macsec_config(
        &self,
        _req: crate::model::interconnects::GetMacsecConfigRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<
            gax::response::Response<crate::model::InterconnectsGetMacsecConfigResponse>,
        >,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Interconnects::insert].
    fn insert(
        &self,
        _req: crate::model::interconnects::InsertRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Interconnects::list].
    fn list(
        &self,
        _req: crate::model::interconnects::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::InterconnectList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Interconnects::patch].
    fn patch(
        &self,
        _req: crate::model::interconnects::PatchRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Interconnects::set_labels].
    fn set_labels(
        &self,
        _req: crate::model::interconnects::SetLabelsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Interconnects::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::global_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::LicenseCodes].
///
/// Application developers may need to implement this trait to mock
/// `client::LicenseCodes`.  In other use-cases, application developers only
/// use `client::LicenseCodes` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "license-codes")]
#[cfg_attr(docsrs, doc(cfg(feature = "license-codes")))]
pub trait LicenseCodes: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::LicenseCodes::get].
    fn get(
        &self,
        _req: crate::model::license_codes::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::LicenseCode>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::LicenseCodes::test_iam_permissions].
    fn test_iam_permissions(
        &self,
        _req: crate::model::license_codes::TestIamPermissionsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }
}

/// Defines the trait used to implement [super::client::Licenses].
///
/// Application developers may need to implement this trait to mock
/// `client::Licenses`.  In other use-cases, application developers only
/// use `client::Licenses` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "licenses")]
#[cfg_attr(docsrs, doc(cfg(feature = "licenses")))]
pub trait Licenses: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::Licenses::delete].
    fn delete(
        &self,
        _req: crate::model::licenses::DeleteRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Licenses::get].
    fn get(
        &self,
        _req: crate::model::licenses::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::License>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Licenses::get_iam_policy].
    fn get_iam_policy(
        &self,
        _req: crate::model::licenses::GetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Policy>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Licenses::insert].
    fn insert(
        &self,
        _req: crate::model::licenses::InsertRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Licenses::list].
    fn list(
        &self,
        _req: crate::model::licenses::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::LicensesListResponse>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Licenses::set_iam_policy].
    fn set_iam_policy(
        &self,
        _req: crate::model::licenses::SetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Policy>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Licenses::test_iam_permissions].
    fn test_iam_permissions(
        &self,
        _req: crate::model::licenses::TestIamPermissionsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Licenses::update].
    fn update(
        &self,
        _req: crate::model::licenses::UpdateRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Licenses::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::global_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::MachineImages].
///
/// Application developers may need to implement this trait to mock
/// `client::MachineImages`.  In other use-cases, application developers only
/// use `client::MachineImages` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "machine-images")]
#[cfg_attr(docsrs, doc(cfg(feature = "machine-images")))]
pub trait MachineImages: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::MachineImages::delete].
    fn delete(
        &self,
        _req: crate::model::machine_images::DeleteRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::MachineImages::get].
    fn get(
        &self,
        _req: crate::model::machine_images::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::MachineImage>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::MachineImages::get_iam_policy].
    fn get_iam_policy(
        &self,
        _req: crate::model::machine_images::GetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Policy>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::MachineImages::insert].
    fn insert(
        &self,
        _req: crate::model::machine_images::InsertRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::MachineImages::list].
    fn list(
        &self,
        _req: crate::model::machine_images::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::MachineImageList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::MachineImages::set_iam_policy].
    fn set_iam_policy(
        &self,
        _req: crate::model::machine_images::SetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Policy>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::MachineImages::set_labels].
    fn set_labels(
        &self,
        _req: crate::model::machine_images::SetLabelsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::MachineImages::test_iam_permissions].
    fn test_iam_permissions(
        &self,
        _req: crate::model::machine_images::TestIamPermissionsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::MachineImages::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::global_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::MachineTypes].
///
/// Application developers may need to implement this trait to mock
/// `client::MachineTypes`.  In other use-cases, application developers only
/// use `client::MachineTypes` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "machine-types")]
#[cfg_attr(docsrs, doc(cfg(feature = "machine-types")))]
pub trait MachineTypes: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::MachineTypes::aggregated_list].
    fn aggregated_list(
        &self,
        _req: crate::model::machine_types::AggregatedListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::MachineTypeAggregatedList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::MachineTypes::get].
    fn get(
        &self,
        _req: crate::model::machine_types::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::MachineType>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::MachineTypes::list].
    fn list(
        &self,
        _req: crate::model::machine_types::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::MachineTypeList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }
}

/// Defines the trait used to implement [super::client::NetworkAttachments].
///
/// Application developers may need to implement this trait to mock
/// `client::NetworkAttachments`.  In other use-cases, application developers only
/// use `client::NetworkAttachments` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "network-attachments")]
#[cfg_attr(docsrs, doc(cfg(feature = "network-attachments")))]
pub trait NetworkAttachments: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::NetworkAttachments::aggregated_list].
    fn aggregated_list(
        &self,
        _req: crate::model::network_attachments::AggregatedListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<
            gax::response::Response<crate::model::NetworkAttachmentAggregatedList>,
        >,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::NetworkAttachments::delete].
    fn delete(
        &self,
        _req: crate::model::network_attachments::DeleteRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::NetworkAttachments::get].
    fn get(
        &self,
        _req: crate::model::network_attachments::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::NetworkAttachment>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::NetworkAttachments::get_iam_policy].
    fn get_iam_policy(
        &self,
        _req: crate::model::network_attachments::GetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Policy>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::NetworkAttachments::insert].
    fn insert(
        &self,
        _req: crate::model::network_attachments::InsertRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::NetworkAttachments::list].
    fn list(
        &self,
        _req: crate::model::network_attachments::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::NetworkAttachmentList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::NetworkAttachments::patch].
    fn patch(
        &self,
        _req: crate::model::network_attachments::PatchRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::NetworkAttachments::set_iam_policy].
    fn set_iam_policy(
        &self,
        _req: crate::model::network_attachments::SetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Policy>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::NetworkAttachments::test_iam_permissions].
    fn test_iam_permissions(
        &self,
        _req: crate::model::network_attachments::TestIamPermissionsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::NetworkAttachments::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::region_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::NetworkEdgeSecurityServices].
///
/// Application developers may need to implement this trait to mock
/// `client::NetworkEdgeSecurityServices`.  In other use-cases, application developers only
/// use `client::NetworkEdgeSecurityServices` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "network-edge-security-services")]
#[cfg_attr(docsrs, doc(cfg(feature = "network-edge-security-services")))]
pub trait NetworkEdgeSecurityServices: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::NetworkEdgeSecurityServices::aggregated_list].
    fn aggregated_list(
        &self,
        _req: crate::model::network_edge_security_services::AggregatedListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<
            gax::response::Response<crate::model::NetworkEdgeSecurityServiceAggregatedList>,
        >,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::NetworkEdgeSecurityServices::delete].
    fn delete(
        &self,
        _req: crate::model::network_edge_security_services::DeleteRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::NetworkEdgeSecurityServices::get].
    fn get(
        &self,
        _req: crate::model::network_edge_security_services::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::NetworkEdgeSecurityService>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::NetworkEdgeSecurityServices::insert].
    fn insert(
        &self,
        _req: crate::model::network_edge_security_services::InsertRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::NetworkEdgeSecurityServices::patch].
    fn patch(
        &self,
        _req: crate::model::network_edge_security_services::PatchRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::NetworkEdgeSecurityServices::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::region_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::NetworkEndpointGroups].
///
/// Application developers may need to implement this trait to mock
/// `client::NetworkEndpointGroups`.  In other use-cases, application developers only
/// use `client::NetworkEndpointGroups` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "network-endpoint-groups")]
#[cfg_attr(docsrs, doc(cfg(feature = "network-endpoint-groups")))]
pub trait NetworkEndpointGroups: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::NetworkEndpointGroups::aggregated_list].
    fn aggregated_list(
        &self,
        _req: crate::model::network_endpoint_groups::AggregatedListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<
            gax::response::Response<crate::model::NetworkEndpointGroupAggregatedList>,
        >,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::NetworkEndpointGroups::attach_network_endpoints].
    fn attach_network_endpoints(
        &self,
        _req: crate::model::network_endpoint_groups::AttachNetworkEndpointsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::NetworkEndpointGroups::delete].
    fn delete(
        &self,
        _req: crate::model::network_endpoint_groups::DeleteRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::NetworkEndpointGroups::detach_network_endpoints].
    fn detach_network_endpoints(
        &self,
        _req: crate::model::network_endpoint_groups::DetachNetworkEndpointsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::NetworkEndpointGroups::get].
    fn get(
        &self,
        _req: crate::model::network_endpoint_groups::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::NetworkEndpointGroup>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::NetworkEndpointGroups::insert].
    fn insert(
        &self,
        _req: crate::model::network_endpoint_groups::InsertRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::NetworkEndpointGroups::list].
    fn list(
        &self,
        _req: crate::model::network_endpoint_groups::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::NetworkEndpointGroupList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::NetworkEndpointGroups::list_network_endpoints].
    fn list_network_endpoints(
        &self,
        _req: crate::model::network_endpoint_groups::ListNetworkEndpointsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<
            gax::response::Response<crate::model::NetworkEndpointGroupsListNetworkEndpoints>,
        >,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::NetworkEndpointGroups::test_iam_permissions].
    fn test_iam_permissions(
        &self,
        _req: crate::model::network_endpoint_groups::TestIamPermissionsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::NetworkEndpointGroups::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::zone_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::NetworkFirewallPolicies].
///
/// Application developers may need to implement this trait to mock
/// `client::NetworkFirewallPolicies`.  In other use-cases, application developers only
/// use `client::NetworkFirewallPolicies` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "network-firewall-policies")]
#[cfg_attr(docsrs, doc(cfg(feature = "network-firewall-policies")))]
pub trait NetworkFirewallPolicies: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::NetworkFirewallPolicies::add_association].
    fn add_association(
        &self,
        _req: crate::model::network_firewall_policies::AddAssociationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::NetworkFirewallPolicies::add_packet_mirroring_rule].
    fn add_packet_mirroring_rule(
        &self,
        _req: crate::model::network_firewall_policies::AddPacketMirroringRuleRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::NetworkFirewallPolicies::add_rule].
    fn add_rule(
        &self,
        _req: crate::model::network_firewall_policies::AddRuleRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::NetworkFirewallPolicies::aggregated_list].
    fn aggregated_list(
        &self,
        _req: crate::model::network_firewall_policies::AggregatedListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<
            gax::response::Response<crate::model::NetworkFirewallPolicyAggregatedList>,
        >,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::NetworkFirewallPolicies::clone_rules].
    fn clone_rules(
        &self,
        _req: crate::model::network_firewall_policies::CloneRulesRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::NetworkFirewallPolicies::delete].
    fn delete(
        &self,
        _req: crate::model::network_firewall_policies::DeleteRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::NetworkFirewallPolicies::get].
    fn get(
        &self,
        _req: crate::model::network_firewall_policies::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::FirewallPolicy>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::NetworkFirewallPolicies::get_association].
    fn get_association(
        &self,
        _req: crate::model::network_firewall_policies::GetAssociationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::FirewallPolicyAssociation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::NetworkFirewallPolicies::get_iam_policy].
    fn get_iam_policy(
        &self,
        _req: crate::model::network_firewall_policies::GetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Policy>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::NetworkFirewallPolicies::get_packet_mirroring_rule].
    fn get_packet_mirroring_rule(
        &self,
        _req: crate::model::network_firewall_policies::GetPacketMirroringRuleRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::FirewallPolicyRule>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::NetworkFirewallPolicies::get_rule].
    fn get_rule(
        &self,
        _req: crate::model::network_firewall_policies::GetRuleRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::FirewallPolicyRule>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::NetworkFirewallPolicies::insert].
    fn insert(
        &self,
        _req: crate::model::network_firewall_policies::InsertRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::NetworkFirewallPolicies::list].
    fn list(
        &self,
        _req: crate::model::network_firewall_policies::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::FirewallPolicyList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::NetworkFirewallPolicies::patch].
    fn patch(
        &self,
        _req: crate::model::network_firewall_policies::PatchRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::NetworkFirewallPolicies::patch_packet_mirroring_rule].
    fn patch_packet_mirroring_rule(
        &self,
        _req: crate::model::network_firewall_policies::PatchPacketMirroringRuleRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::NetworkFirewallPolicies::patch_rule].
    fn patch_rule(
        &self,
        _req: crate::model::network_firewall_policies::PatchRuleRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::NetworkFirewallPolicies::remove_association].
    fn remove_association(
        &self,
        _req: crate::model::network_firewall_policies::RemoveAssociationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::NetworkFirewallPolicies::remove_packet_mirroring_rule].
    fn remove_packet_mirroring_rule(
        &self,
        _req: crate::model::network_firewall_policies::RemovePacketMirroringRuleRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::NetworkFirewallPolicies::remove_rule].
    fn remove_rule(
        &self,
        _req: crate::model::network_firewall_policies::RemoveRuleRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::NetworkFirewallPolicies::set_iam_policy].
    fn set_iam_policy(
        &self,
        _req: crate::model::network_firewall_policies::SetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Policy>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::NetworkFirewallPolicies::test_iam_permissions].
    fn test_iam_permissions(
        &self,
        _req: crate::model::network_firewall_policies::TestIamPermissionsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::NetworkFirewallPolicies::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::global_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::NetworkProfiles].
///
/// Application developers may need to implement this trait to mock
/// `client::NetworkProfiles`.  In other use-cases, application developers only
/// use `client::NetworkProfiles` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "network-profiles")]
#[cfg_attr(docsrs, doc(cfg(feature = "network-profiles")))]
pub trait NetworkProfiles: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::NetworkProfiles::get].
    fn get(
        &self,
        _req: crate::model::network_profiles::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::NetworkProfile>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::NetworkProfiles::list].
    fn list(
        &self,
        _req: crate::model::network_profiles::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::NetworkProfilesListResponse>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }
}

/// Defines the trait used to implement [super::client::Networks].
///
/// Application developers may need to implement this trait to mock
/// `client::Networks`.  In other use-cases, application developers only
/// use `client::Networks` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "networks")]
#[cfg_attr(docsrs, doc(cfg(feature = "networks")))]
pub trait Networks: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::Networks::add_peering].
    fn add_peering(
        &self,
        _req: crate::model::networks::AddPeeringRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Networks::delete].
    fn delete(
        &self,
        _req: crate::model::networks::DeleteRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Networks::get].
    fn get(
        &self,
        _req: crate::model::networks::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Network>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Networks::get_effective_firewalls].
    fn get_effective_firewalls(
        &self,
        _req: crate::model::networks::GetEffectiveFirewallsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<
            gax::response::Response<crate::model::NetworksGetEffectiveFirewallsResponse>,
        >,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Networks::insert].
    fn insert(
        &self,
        _req: crate::model::networks::InsertRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Networks::list].
    fn list(
        &self,
        _req: crate::model::networks::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::NetworkList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Networks::list_peering_routes].
    fn list_peering_routes(
        &self,
        _req: crate::model::networks::ListPeeringRoutesRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::ExchangedPeeringRoutesList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Networks::patch].
    fn patch(
        &self,
        _req: crate::model::networks::PatchRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Networks::remove_peering].
    fn remove_peering(
        &self,
        _req: crate::model::networks::RemovePeeringRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Networks::request_remove_peering].
    fn request_remove_peering(
        &self,
        _req: crate::model::networks::RequestRemovePeeringRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Networks::switch_to_custom_mode].
    fn switch_to_custom_mode(
        &self,
        _req: crate::model::networks::SwitchToCustomModeRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Networks::update_peering].
    fn update_peering(
        &self,
        _req: crate::model::networks::UpdatePeeringRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Networks::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::global_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::NodeGroups].
///
/// Application developers may need to implement this trait to mock
/// `client::NodeGroups`.  In other use-cases, application developers only
/// use `client::NodeGroups` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "node-groups")]
#[cfg_attr(docsrs, doc(cfg(feature = "node-groups")))]
pub trait NodeGroups: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::NodeGroups::add_nodes].
    fn add_nodes(
        &self,
        _req: crate::model::node_groups::AddNodesRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::NodeGroups::aggregated_list].
    fn aggregated_list(
        &self,
        _req: crate::model::node_groups::AggregatedListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::NodeGroupAggregatedList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::NodeGroups::delete].
    fn delete(
        &self,
        _req: crate::model::node_groups::DeleteRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::NodeGroups::delete_nodes].
    fn delete_nodes(
        &self,
        _req: crate::model::node_groups::DeleteNodesRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::NodeGroups::get].
    fn get(
        &self,
        _req: crate::model::node_groups::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::NodeGroup>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::NodeGroups::get_iam_policy].
    fn get_iam_policy(
        &self,
        _req: crate::model::node_groups::GetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Policy>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::NodeGroups::insert].
    fn insert(
        &self,
        _req: crate::model::node_groups::InsertRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::NodeGroups::list].
    fn list(
        &self,
        _req: crate::model::node_groups::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::NodeGroupList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::NodeGroups::list_nodes].
    fn list_nodes(
        &self,
        _req: crate::model::node_groups::ListNodesRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::NodeGroupsListNodes>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::NodeGroups::patch].
    fn patch(
        &self,
        _req: crate::model::node_groups::PatchRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::NodeGroups::perform_maintenance].
    fn perform_maintenance(
        &self,
        _req: crate::model::node_groups::PerformMaintenanceRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::NodeGroups::set_iam_policy].
    fn set_iam_policy(
        &self,
        _req: crate::model::node_groups::SetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Policy>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::NodeGroups::set_node_template].
    fn set_node_template(
        &self,
        _req: crate::model::node_groups::SetNodeTemplateRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::NodeGroups::simulate_maintenance_event].
    fn simulate_maintenance_event(
        &self,
        _req: crate::model::node_groups::SimulateMaintenanceEventRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::NodeGroups::test_iam_permissions].
    fn test_iam_permissions(
        &self,
        _req: crate::model::node_groups::TestIamPermissionsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::NodeGroups::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::zone_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::NodeTemplates].
///
/// Application developers may need to implement this trait to mock
/// `client::NodeTemplates`.  In other use-cases, application developers only
/// use `client::NodeTemplates` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "node-templates")]
#[cfg_attr(docsrs, doc(cfg(feature = "node-templates")))]
pub trait NodeTemplates: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::NodeTemplates::aggregated_list].
    fn aggregated_list(
        &self,
        _req: crate::model::node_templates::AggregatedListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::NodeTemplateAggregatedList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::NodeTemplates::delete].
    fn delete(
        &self,
        _req: crate::model::node_templates::DeleteRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::NodeTemplates::get].
    fn get(
        &self,
        _req: crate::model::node_templates::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::NodeTemplate>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::NodeTemplates::get_iam_policy].
    fn get_iam_policy(
        &self,
        _req: crate::model::node_templates::GetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Policy>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::NodeTemplates::insert].
    fn insert(
        &self,
        _req: crate::model::node_templates::InsertRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::NodeTemplates::list].
    fn list(
        &self,
        _req: crate::model::node_templates::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::NodeTemplateList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::NodeTemplates::set_iam_policy].
    fn set_iam_policy(
        &self,
        _req: crate::model::node_templates::SetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Policy>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::NodeTemplates::test_iam_permissions].
    fn test_iam_permissions(
        &self,
        _req: crate::model::node_templates::TestIamPermissionsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::NodeTemplates::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::region_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::NodeTypes].
///
/// Application developers may need to implement this trait to mock
/// `client::NodeTypes`.  In other use-cases, application developers only
/// use `client::NodeTypes` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "node-types")]
#[cfg_attr(docsrs, doc(cfg(feature = "node-types")))]
pub trait NodeTypes: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::NodeTypes::aggregated_list].
    fn aggregated_list(
        &self,
        _req: crate::model::node_types::AggregatedListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::NodeTypeAggregatedList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::NodeTypes::get].
    fn get(
        &self,
        _req: crate::model::node_types::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::NodeType>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::NodeTypes::list].
    fn list(
        &self,
        _req: crate::model::node_types::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::NodeTypeList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }
}

/// Defines the trait used to implement [super::client::OrganizationSecurityPolicies].
///
/// Application developers may need to implement this trait to mock
/// `client::OrganizationSecurityPolicies`.  In other use-cases, application developers only
/// use `client::OrganizationSecurityPolicies` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "organization-security-policies")]
#[cfg_attr(docsrs, doc(cfg(feature = "organization-security-policies")))]
pub trait OrganizationSecurityPolicies: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::OrganizationSecurityPolicies::add_association].
    fn add_association(
        &self,
        _req: crate::model::organization_security_policies::AddAssociationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::OrganizationSecurityPolicies::add_rule].
    fn add_rule(
        &self,
        _req: crate::model::organization_security_policies::AddRuleRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::OrganizationSecurityPolicies::copy_rules].
    fn copy_rules(
        &self,
        _req: crate::model::organization_security_policies::CopyRulesRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::OrganizationSecurityPolicies::delete].
    fn delete(
        &self,
        _req: crate::model::organization_security_policies::DeleteRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::OrganizationSecurityPolicies::get].
    fn get(
        &self,
        _req: crate::model::organization_security_policies::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::SecurityPolicy>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::OrganizationSecurityPolicies::get_association].
    fn get_association(
        &self,
        _req: crate::model::organization_security_policies::GetAssociationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::SecurityPolicyAssociation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::OrganizationSecurityPolicies::get_rule].
    fn get_rule(
        &self,
        _req: crate::model::organization_security_policies::GetRuleRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::SecurityPolicyRule>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::OrganizationSecurityPolicies::insert].
    fn insert(
        &self,
        _req: crate::model::organization_security_policies::InsertRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::OrganizationSecurityPolicies::list].
    fn list(
        &self,
        _req: crate::model::organization_security_policies::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::SecurityPolicyList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::OrganizationSecurityPolicies::list_associations].
    fn list_associations(
        &self,
        _req: crate::model::organization_security_policies::ListAssociationsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<
            gax::response::Response<
                crate::model::OrganizationSecurityPoliciesListAssociationsResponse,
            >,
        >,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::OrganizationSecurityPolicies::list_preconfigured_expression_sets].
    fn list_preconfigured_expression_sets(
        &self,
        _req: crate::model::organization_security_policies::ListPreconfiguredExpressionSetsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<
            gax::response::Response<
                crate::model::SecurityPoliciesListPreconfiguredExpressionSetsResponse,
            >,
        >,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::OrganizationSecurityPolicies::r#move].
    fn r#move(
        &self,
        _req: crate::model::organization_security_policies::MoveRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::OrganizationSecurityPolicies::patch].
    fn patch(
        &self,
        _req: crate::model::organization_security_policies::PatchRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::OrganizationSecurityPolicies::patch_rule].
    fn patch_rule(
        &self,
        _req: crate::model::organization_security_policies::PatchRuleRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::OrganizationSecurityPolicies::remove_association].
    fn remove_association(
        &self,
        _req: crate::model::organization_security_policies::RemoveAssociationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::OrganizationSecurityPolicies::remove_rule].
    fn remove_rule(
        &self,
        _req: crate::model::organization_security_policies::RemoveRuleRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::OrganizationSecurityPolicies::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::global_organization_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::PacketMirrorings].
///
/// Application developers may need to implement this trait to mock
/// `client::PacketMirrorings`.  In other use-cases, application developers only
/// use `client::PacketMirrorings` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "packet-mirrorings")]
#[cfg_attr(docsrs, doc(cfg(feature = "packet-mirrorings")))]
pub trait PacketMirrorings: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::PacketMirrorings::aggregated_list].
    fn aggregated_list(
        &self,
        _req: crate::model::packet_mirrorings::AggregatedListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<
            gax::response::Response<crate::model::PacketMirroringAggregatedList>,
        >,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::PacketMirrorings::delete].
    fn delete(
        &self,
        _req: crate::model::packet_mirrorings::DeleteRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::PacketMirrorings::get].
    fn get(
        &self,
        _req: crate::model::packet_mirrorings::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::PacketMirroring>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::PacketMirrorings::insert].
    fn insert(
        &self,
        _req: crate::model::packet_mirrorings::InsertRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::PacketMirrorings::list].
    fn list(
        &self,
        _req: crate::model::packet_mirrorings::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::PacketMirroringList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::PacketMirrorings::patch].
    fn patch(
        &self,
        _req: crate::model::packet_mirrorings::PatchRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::PacketMirrorings::test_iam_permissions].
    fn test_iam_permissions(
        &self,
        _req: crate::model::packet_mirrorings::TestIamPermissionsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::PacketMirrorings::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::region_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::PreviewFeatures].
///
/// Application developers may need to implement this trait to mock
/// `client::PreviewFeatures`.  In other use-cases, application developers only
/// use `client::PreviewFeatures` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "preview-features")]
#[cfg_attr(docsrs, doc(cfg(feature = "preview-features")))]
pub trait PreviewFeatures: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::PreviewFeatures::get].
    fn get(
        &self,
        _req: crate::model::preview_features::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::PreviewFeature>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::PreviewFeatures::list].
    fn list(
        &self,
        _req: crate::model::preview_features::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::PreviewFeatureList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::PreviewFeatures::update].
    fn update(
        &self,
        _req: crate::model::preview_features::UpdateRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::PreviewFeatures::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::global_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::Projects].
///
/// Application developers may need to implement this trait to mock
/// `client::Projects`.  In other use-cases, application developers only
/// use `client::Projects` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "projects")]
#[cfg_attr(docsrs, doc(cfg(feature = "projects")))]
pub trait Projects: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::Projects::disable_xpn_host].
    fn disable_xpn_host(
        &self,
        _req: crate::model::projects::DisableXpnHostRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Projects::disable_xpn_resource].
    fn disable_xpn_resource(
        &self,
        _req: crate::model::projects::DisableXpnResourceRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Projects::enable_xpn_host].
    fn enable_xpn_host(
        &self,
        _req: crate::model::projects::EnableXpnHostRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Projects::enable_xpn_resource].
    fn enable_xpn_resource(
        &self,
        _req: crate::model::projects::EnableXpnResourceRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Projects::get].
    fn get(
        &self,
        _req: crate::model::projects::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Project>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Projects::get_xpn_host].
    fn get_xpn_host(
        &self,
        _req: crate::model::projects::GetXpnHostRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Project>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Projects::get_xpn_resources].
    fn get_xpn_resources(
        &self,
        _req: crate::model::projects::GetXpnResourcesRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::ProjectsGetXpnResources>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Projects::list_xpn_hosts].
    fn list_xpn_hosts(
        &self,
        _req: crate::model::projects::ListXpnHostsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::XpnHostList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Projects::move_disk].
    fn move_disk(
        &self,
        _req: crate::model::projects::MoveDiskRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Projects::move_instance].
    fn move_instance(
        &self,
        _req: crate::model::projects::MoveInstanceRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Projects::set_cloud_armor_tier].
    fn set_cloud_armor_tier(
        &self,
        _req: crate::model::projects::SetCloudArmorTierRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Projects::set_common_instance_metadata].
    fn set_common_instance_metadata(
        &self,
        _req: crate::model::projects::SetCommonInstanceMetadataRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Projects::set_default_network_tier].
    fn set_default_network_tier(
        &self,
        _req: crate::model::projects::SetDefaultNetworkTierRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Projects::set_usage_export_bucket].
    fn set_usage_export_bucket(
        &self,
        _req: crate::model::projects::SetUsageExportBucketRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Projects::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::global_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::PublicAdvertisedPrefixes].
///
/// Application developers may need to implement this trait to mock
/// `client::PublicAdvertisedPrefixes`.  In other use-cases, application developers only
/// use `client::PublicAdvertisedPrefixes` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "public-advertised-prefixes")]
#[cfg_attr(docsrs, doc(cfg(feature = "public-advertised-prefixes")))]
pub trait PublicAdvertisedPrefixes: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::PublicAdvertisedPrefixes::announce].
    fn announce(
        &self,
        _req: crate::model::public_advertised_prefixes::AnnounceRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::PublicAdvertisedPrefixes::delete].
    fn delete(
        &self,
        _req: crate::model::public_advertised_prefixes::DeleteRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::PublicAdvertisedPrefixes::get].
    fn get(
        &self,
        _req: crate::model::public_advertised_prefixes::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::PublicAdvertisedPrefix>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::PublicAdvertisedPrefixes::insert].
    fn insert(
        &self,
        _req: crate::model::public_advertised_prefixes::InsertRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::PublicAdvertisedPrefixes::list].
    fn list(
        &self,
        _req: crate::model::public_advertised_prefixes::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::PublicAdvertisedPrefixList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::PublicAdvertisedPrefixes::patch].
    fn patch(
        &self,
        _req: crate::model::public_advertised_prefixes::PatchRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::PublicAdvertisedPrefixes::withdraw].
    fn withdraw(
        &self,
        _req: crate::model::public_advertised_prefixes::WithdrawRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::PublicAdvertisedPrefixes::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::global_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::PublicDelegatedPrefixes].
///
/// Application developers may need to implement this trait to mock
/// `client::PublicDelegatedPrefixes`.  In other use-cases, application developers only
/// use `client::PublicDelegatedPrefixes` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "public-delegated-prefixes")]
#[cfg_attr(docsrs, doc(cfg(feature = "public-delegated-prefixes")))]
pub trait PublicDelegatedPrefixes: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::PublicDelegatedPrefixes::aggregated_list].
    fn aggregated_list(
        &self,
        _req: crate::model::public_delegated_prefixes::AggregatedListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<
            gax::response::Response<crate::model::PublicDelegatedPrefixAggregatedList>,
        >,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::PublicDelegatedPrefixes::announce].
    fn announce(
        &self,
        _req: crate::model::public_delegated_prefixes::AnnounceRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::PublicDelegatedPrefixes::delete].
    fn delete(
        &self,
        _req: crate::model::public_delegated_prefixes::DeleteRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::PublicDelegatedPrefixes::get].
    fn get(
        &self,
        _req: crate::model::public_delegated_prefixes::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::PublicDelegatedPrefix>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::PublicDelegatedPrefixes::insert].
    fn insert(
        &self,
        _req: crate::model::public_delegated_prefixes::InsertRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::PublicDelegatedPrefixes::list].
    fn list(
        &self,
        _req: crate::model::public_delegated_prefixes::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::PublicDelegatedPrefixList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::PublicDelegatedPrefixes::patch].
    fn patch(
        &self,
        _req: crate::model::public_delegated_prefixes::PatchRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::PublicDelegatedPrefixes::withdraw].
    fn withdraw(
        &self,
        _req: crate::model::public_delegated_prefixes::WithdrawRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::PublicDelegatedPrefixes::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::region_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::RegionAutoscalers].
///
/// Application developers may need to implement this trait to mock
/// `client::RegionAutoscalers`.  In other use-cases, application developers only
/// use `client::RegionAutoscalers` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "region-autoscalers")]
#[cfg_attr(docsrs, doc(cfg(feature = "region-autoscalers")))]
pub trait RegionAutoscalers: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::RegionAutoscalers::delete].
    fn delete(
        &self,
        _req: crate::model::region_autoscalers::DeleteRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionAutoscalers::get].
    fn get(
        &self,
        _req: crate::model::region_autoscalers::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Autoscaler>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionAutoscalers::insert].
    fn insert(
        &self,
        _req: crate::model::region_autoscalers::InsertRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionAutoscalers::list].
    fn list(
        &self,
        _req: crate::model::region_autoscalers::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::RegionAutoscalerList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionAutoscalers::patch].
    fn patch(
        &self,
        _req: crate::model::region_autoscalers::PatchRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionAutoscalers::update].
    fn update(
        &self,
        _req: crate::model::region_autoscalers::UpdateRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionAutoscalers::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::region_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::RegionBackendServices].
///
/// Application developers may need to implement this trait to mock
/// `client::RegionBackendServices`.  In other use-cases, application developers only
/// use `client::RegionBackendServices` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "region-backend-services")]
#[cfg_attr(docsrs, doc(cfg(feature = "region-backend-services")))]
pub trait RegionBackendServices: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::RegionBackendServices::delete].
    fn delete(
        &self,
        _req: crate::model::region_backend_services::DeleteRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionBackendServices::get].
    fn get(
        &self,
        _req: crate::model::region_backend_services::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::BackendService>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionBackendServices::get_health].
    fn get_health(
        &self,
        _req: crate::model::region_backend_services::GetHealthRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::BackendServiceGroupHealth>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionBackendServices::get_iam_policy].
    fn get_iam_policy(
        &self,
        _req: crate::model::region_backend_services::GetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Policy>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionBackendServices::insert].
    fn insert(
        &self,
        _req: crate::model::region_backend_services::InsertRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionBackendServices::list].
    fn list(
        &self,
        _req: crate::model::region_backend_services::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::BackendServiceList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionBackendServices::list_usable].
    fn list_usable(
        &self,
        _req: crate::model::region_backend_services::ListUsableRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::BackendServiceListUsable>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionBackendServices::patch].
    fn patch(
        &self,
        _req: crate::model::region_backend_services::PatchRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionBackendServices::set_iam_policy].
    fn set_iam_policy(
        &self,
        _req: crate::model::region_backend_services::SetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Policy>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionBackendServices::set_security_policy].
    fn set_security_policy(
        &self,
        _req: crate::model::region_backend_services::SetSecurityPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionBackendServices::test_iam_permissions].
    fn test_iam_permissions(
        &self,
        _req: crate::model::region_backend_services::TestIamPermissionsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionBackendServices::update].
    fn update(
        &self,
        _req: crate::model::region_backend_services::UpdateRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionBackendServices::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::region_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::RegionCommitments].
///
/// Application developers may need to implement this trait to mock
/// `client::RegionCommitments`.  In other use-cases, application developers only
/// use `client::RegionCommitments` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "region-commitments")]
#[cfg_attr(docsrs, doc(cfg(feature = "region-commitments")))]
pub trait RegionCommitments: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::RegionCommitments::aggregated_list].
    fn aggregated_list(
        &self,
        _req: crate::model::region_commitments::AggregatedListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::CommitmentAggregatedList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionCommitments::get].
    fn get(
        &self,
        _req: crate::model::region_commitments::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Commitment>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionCommitments::insert].
    fn insert(
        &self,
        _req: crate::model::region_commitments::InsertRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionCommitments::list].
    fn list(
        &self,
        _req: crate::model::region_commitments::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::CommitmentList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionCommitments::update].
    fn update(
        &self,
        _req: crate::model::region_commitments::UpdateRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionCommitments::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::region_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::RegionDiskTypes].
///
/// Application developers may need to implement this trait to mock
/// `client::RegionDiskTypes`.  In other use-cases, application developers only
/// use `client::RegionDiskTypes` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "region-disk-types")]
#[cfg_attr(docsrs, doc(cfg(feature = "region-disk-types")))]
pub trait RegionDiskTypes: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::RegionDiskTypes::get].
    fn get(
        &self,
        _req: crate::model::region_disk_types::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::DiskType>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionDiskTypes::list].
    fn list(
        &self,
        _req: crate::model::region_disk_types::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::RegionDiskTypeList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }
}

/// Defines the trait used to implement [super::client::RegionDisks].
///
/// Application developers may need to implement this trait to mock
/// `client::RegionDisks`.  In other use-cases, application developers only
/// use `client::RegionDisks` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "region-disks")]
#[cfg_attr(docsrs, doc(cfg(feature = "region-disks")))]
pub trait RegionDisks: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::RegionDisks::add_resource_policies].
    fn add_resource_policies(
        &self,
        _req: crate::model::region_disks::AddResourcePoliciesRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionDisks::bulk_insert].
    fn bulk_insert(
        &self,
        _req: crate::model::region_disks::BulkInsertRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionDisks::create_snapshot].
    fn create_snapshot(
        &self,
        _req: crate::model::region_disks::CreateSnapshotRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionDisks::delete].
    fn delete(
        &self,
        _req: crate::model::region_disks::DeleteRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionDisks::get].
    fn get(
        &self,
        _req: crate::model::region_disks::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Disk>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionDisks::get_iam_policy].
    fn get_iam_policy(
        &self,
        _req: crate::model::region_disks::GetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Policy>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionDisks::insert].
    fn insert(
        &self,
        _req: crate::model::region_disks::InsertRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionDisks::list].
    fn list(
        &self,
        _req: crate::model::region_disks::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::DiskList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionDisks::remove_resource_policies].
    fn remove_resource_policies(
        &self,
        _req: crate::model::region_disks::RemoveResourcePoliciesRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionDisks::resize].
    fn resize(
        &self,
        _req: crate::model::region_disks::ResizeRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionDisks::set_iam_policy].
    fn set_iam_policy(
        &self,
        _req: crate::model::region_disks::SetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Policy>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionDisks::set_labels].
    fn set_labels(
        &self,
        _req: crate::model::region_disks::SetLabelsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionDisks::start_async_replication].
    fn start_async_replication(
        &self,
        _req: crate::model::region_disks::StartAsyncReplicationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionDisks::stop_async_replication].
    fn stop_async_replication(
        &self,
        _req: crate::model::region_disks::StopAsyncReplicationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionDisks::stop_group_async_replication].
    fn stop_group_async_replication(
        &self,
        _req: crate::model::region_disks::StopGroupAsyncReplicationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionDisks::test_iam_permissions].
    fn test_iam_permissions(
        &self,
        _req: crate::model::region_disks::TestIamPermissionsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionDisks::update].
    fn update(
        &self,
        _req: crate::model::region_disks::UpdateRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionDisks::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::region_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::RegionHealthCheckServices].
///
/// Application developers may need to implement this trait to mock
/// `client::RegionHealthCheckServices`.  In other use-cases, application developers only
/// use `client::RegionHealthCheckServices` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "region-health-check-services")]
#[cfg_attr(docsrs, doc(cfg(feature = "region-health-check-services")))]
pub trait RegionHealthCheckServices: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::RegionHealthCheckServices::delete].
    fn delete(
        &self,
        _req: crate::model::region_health_check_services::DeleteRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionHealthCheckServices::get].
    fn get(
        &self,
        _req: crate::model::region_health_check_services::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::HealthCheckService>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionHealthCheckServices::insert].
    fn insert(
        &self,
        _req: crate::model::region_health_check_services::InsertRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionHealthCheckServices::list].
    fn list(
        &self,
        _req: crate::model::region_health_check_services::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::HealthCheckServicesList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionHealthCheckServices::patch].
    fn patch(
        &self,
        _req: crate::model::region_health_check_services::PatchRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionHealthCheckServices::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::region_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::RegionHealthChecks].
///
/// Application developers may need to implement this trait to mock
/// `client::RegionHealthChecks`.  In other use-cases, application developers only
/// use `client::RegionHealthChecks` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "region-health-checks")]
#[cfg_attr(docsrs, doc(cfg(feature = "region-health-checks")))]
pub trait RegionHealthChecks: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::RegionHealthChecks::delete].
    fn delete(
        &self,
        _req: crate::model::region_health_checks::DeleteRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionHealthChecks::get].
    fn get(
        &self,
        _req: crate::model::region_health_checks::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::HealthCheck>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionHealthChecks::insert].
    fn insert(
        &self,
        _req: crate::model::region_health_checks::InsertRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionHealthChecks::list].
    fn list(
        &self,
        _req: crate::model::region_health_checks::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::HealthCheckList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionHealthChecks::patch].
    fn patch(
        &self,
        _req: crate::model::region_health_checks::PatchRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionHealthChecks::update].
    fn update(
        &self,
        _req: crate::model::region_health_checks::UpdateRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionHealthChecks::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::region_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::RegionInstanceGroupManagers].
///
/// Application developers may need to implement this trait to mock
/// `client::RegionInstanceGroupManagers`.  In other use-cases, application developers only
/// use `client::RegionInstanceGroupManagers` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "region-instance-group-managers")]
#[cfg_attr(docsrs, doc(cfg(feature = "region-instance-group-managers")))]
pub trait RegionInstanceGroupManagers: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::RegionInstanceGroupManagers::abandon_instances].
    fn abandon_instances(
        &self,
        _req: crate::model::region_instance_group_managers::AbandonInstancesRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionInstanceGroupManagers::apply_updates_to_instances].
    fn apply_updates_to_instances(
        &self,
        _req: crate::model::region_instance_group_managers::ApplyUpdatesToInstancesRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionInstanceGroupManagers::create_instances].
    fn create_instances(
        &self,
        _req: crate::model::region_instance_group_managers::CreateInstancesRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionInstanceGroupManagers::delete].
    fn delete(
        &self,
        _req: crate::model::region_instance_group_managers::DeleteRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionInstanceGroupManagers::delete_instances].
    fn delete_instances(
        &self,
        _req: crate::model::region_instance_group_managers::DeleteInstancesRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionInstanceGroupManagers::delete_per_instance_configs].
    fn delete_per_instance_configs(
        &self,
        _req: crate::model::region_instance_group_managers::DeletePerInstanceConfigsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionInstanceGroupManagers::get].
    fn get(
        &self,
        _req: crate::model::region_instance_group_managers::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::InstanceGroupManager>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionInstanceGroupManagers::insert].
    fn insert(
        &self,
        _req: crate::model::region_instance_group_managers::InsertRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionInstanceGroupManagers::list].
    fn list(
        &self,
        _req: crate::model::region_instance_group_managers::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<
            gax::response::Response<crate::model::RegionInstanceGroupManagerList>,
        >,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionInstanceGroupManagers::list_errors].
    fn list_errors(
        &self,
        _req: crate::model::region_instance_group_managers::ListErrorsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<
            gax::response::Response<crate::model::RegionInstanceGroupManagersListErrorsResponse>,
        >,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionInstanceGroupManagers::list_managed_instances].
    fn list_managed_instances(
        &self,
        _req: crate::model::region_instance_group_managers::ListManagedInstancesRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<
            gax::response::Response<crate::model::RegionInstanceGroupManagersListInstancesResponse>,
        >,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionInstanceGroupManagers::list_per_instance_configs].
    fn list_per_instance_configs(
        &self,
        _req: crate::model::region_instance_group_managers::ListPerInstanceConfigsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<
            gax::response::Response<
                crate::model::RegionInstanceGroupManagersListInstanceConfigsResp,
            >,
        >,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionInstanceGroupManagers::patch].
    fn patch(
        &self,
        _req: crate::model::region_instance_group_managers::PatchRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionInstanceGroupManagers::patch_per_instance_configs].
    fn patch_per_instance_configs(
        &self,
        _req: crate::model::region_instance_group_managers::PatchPerInstanceConfigsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionInstanceGroupManagers::recreate_instances].
    fn recreate_instances(
        &self,
        _req: crate::model::region_instance_group_managers::RecreateInstancesRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionInstanceGroupManagers::resize].
    fn resize(
        &self,
        _req: crate::model::region_instance_group_managers::ResizeRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionInstanceGroupManagers::resume_instances].
    fn resume_instances(
        &self,
        _req: crate::model::region_instance_group_managers::ResumeInstancesRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionInstanceGroupManagers::set_instance_template].
    fn set_instance_template(
        &self,
        _req: crate::model::region_instance_group_managers::SetInstanceTemplateRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionInstanceGroupManagers::set_target_pools].
    fn set_target_pools(
        &self,
        _req: crate::model::region_instance_group_managers::SetTargetPoolsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionInstanceGroupManagers::start_instances].
    fn start_instances(
        &self,
        _req: crate::model::region_instance_group_managers::StartInstancesRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionInstanceGroupManagers::stop_instances].
    fn stop_instances(
        &self,
        _req: crate::model::region_instance_group_managers::StopInstancesRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionInstanceGroupManagers::suspend_instances].
    fn suspend_instances(
        &self,
        _req: crate::model::region_instance_group_managers::SuspendInstancesRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionInstanceGroupManagers::update_per_instance_configs].
    fn update_per_instance_configs(
        &self,
        _req: crate::model::region_instance_group_managers::UpdatePerInstanceConfigsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionInstanceGroupManagers::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::region_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::RegionInstanceGroups].
///
/// Application developers may need to implement this trait to mock
/// `client::RegionInstanceGroups`.  In other use-cases, application developers only
/// use `client::RegionInstanceGroups` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "region-instance-groups")]
#[cfg_attr(docsrs, doc(cfg(feature = "region-instance-groups")))]
pub trait RegionInstanceGroups: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::RegionInstanceGroups::get].
    fn get(
        &self,
        _req: crate::model::region_instance_groups::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::InstanceGroup>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionInstanceGroups::list].
    fn list(
        &self,
        _req: crate::model::region_instance_groups::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::RegionInstanceGroupList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionInstanceGroups::list_instances].
    fn list_instances(
        &self,
        _req: crate::model::region_instance_groups::ListInstancesRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<
            gax::response::Response<crate::model::RegionInstanceGroupsListInstances>,
        >,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionInstanceGroups::set_named_ports].
    fn set_named_ports(
        &self,
        _req: crate::model::region_instance_groups::SetNamedPortsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionInstanceGroups::test_iam_permissions].
    fn test_iam_permissions(
        &self,
        _req: crate::model::region_instance_groups::TestIamPermissionsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionInstanceGroups::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::region_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::RegionInstanceTemplates].
///
/// Application developers may need to implement this trait to mock
/// `client::RegionInstanceTemplates`.  In other use-cases, application developers only
/// use `client::RegionInstanceTemplates` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "region-instance-templates")]
#[cfg_attr(docsrs, doc(cfg(feature = "region-instance-templates")))]
pub trait RegionInstanceTemplates: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::RegionInstanceTemplates::delete].
    fn delete(
        &self,
        _req: crate::model::region_instance_templates::DeleteRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionInstanceTemplates::get].
    fn get(
        &self,
        _req: crate::model::region_instance_templates::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::InstanceTemplate>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionInstanceTemplates::insert].
    fn insert(
        &self,
        _req: crate::model::region_instance_templates::InsertRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionInstanceTemplates::list].
    fn list(
        &self,
        _req: crate::model::region_instance_templates::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::InstanceTemplateList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionInstanceTemplates::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::region_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::RegionInstances].
///
/// Application developers may need to implement this trait to mock
/// `client::RegionInstances`.  In other use-cases, application developers only
/// use `client::RegionInstances` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "region-instances")]
#[cfg_attr(docsrs, doc(cfg(feature = "region-instances")))]
pub trait RegionInstances: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::RegionInstances::bulk_insert].
    fn bulk_insert(
        &self,
        _req: crate::model::region_instances::BulkInsertRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionInstances::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::region_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::RegionInstantSnapshots].
///
/// Application developers may need to implement this trait to mock
/// `client::RegionInstantSnapshots`.  In other use-cases, application developers only
/// use `client::RegionInstantSnapshots` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "region-instant-snapshots")]
#[cfg_attr(docsrs, doc(cfg(feature = "region-instant-snapshots")))]
pub trait RegionInstantSnapshots: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::RegionInstantSnapshots::delete].
    fn delete(
        &self,
        _req: crate::model::region_instant_snapshots::DeleteRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionInstantSnapshots::get].
    fn get(
        &self,
        _req: crate::model::region_instant_snapshots::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::InstantSnapshot>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionInstantSnapshots::get_iam_policy].
    fn get_iam_policy(
        &self,
        _req: crate::model::region_instant_snapshots::GetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Policy>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionInstantSnapshots::insert].
    fn insert(
        &self,
        _req: crate::model::region_instant_snapshots::InsertRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionInstantSnapshots::list].
    fn list(
        &self,
        _req: crate::model::region_instant_snapshots::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::InstantSnapshotList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionInstantSnapshots::set_iam_policy].
    fn set_iam_policy(
        &self,
        _req: crate::model::region_instant_snapshots::SetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Policy>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionInstantSnapshots::set_labels].
    fn set_labels(
        &self,
        _req: crate::model::region_instant_snapshots::SetLabelsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionInstantSnapshots::test_iam_permissions].
    fn test_iam_permissions(
        &self,
        _req: crate::model::region_instant_snapshots::TestIamPermissionsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionInstantSnapshots::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::region_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::RegionNetworkEndpointGroups].
///
/// Application developers may need to implement this trait to mock
/// `client::RegionNetworkEndpointGroups`.  In other use-cases, application developers only
/// use `client::RegionNetworkEndpointGroups` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "region-network-endpoint-groups")]
#[cfg_attr(docsrs, doc(cfg(feature = "region-network-endpoint-groups")))]
pub trait RegionNetworkEndpointGroups: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::RegionNetworkEndpointGroups::attach_network_endpoints].
    fn attach_network_endpoints(
        &self,
        _req: crate::model::region_network_endpoint_groups::AttachNetworkEndpointsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionNetworkEndpointGroups::delete].
    fn delete(
        &self,
        _req: crate::model::region_network_endpoint_groups::DeleteRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionNetworkEndpointGroups::detach_network_endpoints].
    fn detach_network_endpoints(
        &self,
        _req: crate::model::region_network_endpoint_groups::DetachNetworkEndpointsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionNetworkEndpointGroups::get].
    fn get(
        &self,
        _req: crate::model::region_network_endpoint_groups::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::NetworkEndpointGroup>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionNetworkEndpointGroups::insert].
    fn insert(
        &self,
        _req: crate::model::region_network_endpoint_groups::InsertRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionNetworkEndpointGroups::list].
    fn list(
        &self,
        _req: crate::model::region_network_endpoint_groups::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::NetworkEndpointGroupList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionNetworkEndpointGroups::list_network_endpoints].
    fn list_network_endpoints(
        &self,
        _req: crate::model::region_network_endpoint_groups::ListNetworkEndpointsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<
            gax::response::Response<crate::model::NetworkEndpointGroupsListNetworkEndpoints>,
        >,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionNetworkEndpointGroups::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::region_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::RegionNetworkFirewallPolicies].
///
/// Application developers may need to implement this trait to mock
/// `client::RegionNetworkFirewallPolicies`.  In other use-cases, application developers only
/// use `client::RegionNetworkFirewallPolicies` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "region-network-firewall-policies")]
#[cfg_attr(docsrs, doc(cfg(feature = "region-network-firewall-policies")))]
pub trait RegionNetworkFirewallPolicies: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::RegionNetworkFirewallPolicies::add_association].
    fn add_association(
        &self,
        _req: crate::model::region_network_firewall_policies::AddAssociationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionNetworkFirewallPolicies::add_rule].
    fn add_rule(
        &self,
        _req: crate::model::region_network_firewall_policies::AddRuleRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionNetworkFirewallPolicies::clone_rules].
    fn clone_rules(
        &self,
        _req: crate::model::region_network_firewall_policies::CloneRulesRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionNetworkFirewallPolicies::delete].
    fn delete(
        &self,
        _req: crate::model::region_network_firewall_policies::DeleteRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionNetworkFirewallPolicies::get].
    fn get(
        &self,
        _req: crate::model::region_network_firewall_policies::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::FirewallPolicy>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionNetworkFirewallPolicies::get_association].
    fn get_association(
        &self,
        _req: crate::model::region_network_firewall_policies::GetAssociationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::FirewallPolicyAssociation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionNetworkFirewallPolicies::get_effective_firewalls].
    fn get_effective_firewalls(
        &self,
        _req: crate::model::region_network_firewall_policies::GetEffectiveFirewallsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<
            gax::response::Response<
                crate::model::RegionNetworkFirewallPoliciesGetEffectiveFirewallsResponse,
            >,
        >,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionNetworkFirewallPolicies::get_iam_policy].
    fn get_iam_policy(
        &self,
        _req: crate::model::region_network_firewall_policies::GetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Policy>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionNetworkFirewallPolicies::get_rule].
    fn get_rule(
        &self,
        _req: crate::model::region_network_firewall_policies::GetRuleRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::FirewallPolicyRule>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionNetworkFirewallPolicies::insert].
    fn insert(
        &self,
        _req: crate::model::region_network_firewall_policies::InsertRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionNetworkFirewallPolicies::list].
    fn list(
        &self,
        _req: crate::model::region_network_firewall_policies::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::FirewallPolicyList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionNetworkFirewallPolicies::patch].
    fn patch(
        &self,
        _req: crate::model::region_network_firewall_policies::PatchRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionNetworkFirewallPolicies::patch_rule].
    fn patch_rule(
        &self,
        _req: crate::model::region_network_firewall_policies::PatchRuleRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionNetworkFirewallPolicies::remove_association].
    fn remove_association(
        &self,
        _req: crate::model::region_network_firewall_policies::RemoveAssociationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionNetworkFirewallPolicies::remove_rule].
    fn remove_rule(
        &self,
        _req: crate::model::region_network_firewall_policies::RemoveRuleRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionNetworkFirewallPolicies::set_iam_policy].
    fn set_iam_policy(
        &self,
        _req: crate::model::region_network_firewall_policies::SetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Policy>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionNetworkFirewallPolicies::test_iam_permissions].
    fn test_iam_permissions(
        &self,
        _req: crate::model::region_network_firewall_policies::TestIamPermissionsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionNetworkFirewallPolicies::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::region_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::RegionNotificationEndpoints].
///
/// Application developers may need to implement this trait to mock
/// `client::RegionNotificationEndpoints`.  In other use-cases, application developers only
/// use `client::RegionNotificationEndpoints` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "region-notification-endpoints")]
#[cfg_attr(docsrs, doc(cfg(feature = "region-notification-endpoints")))]
pub trait RegionNotificationEndpoints: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::RegionNotificationEndpoints::delete].
    fn delete(
        &self,
        _req: crate::model::region_notification_endpoints::DeleteRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionNotificationEndpoints::get].
    fn get(
        &self,
        _req: crate::model::region_notification_endpoints::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::NotificationEndpoint>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionNotificationEndpoints::insert].
    fn insert(
        &self,
        _req: crate::model::region_notification_endpoints::InsertRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionNotificationEndpoints::list].
    fn list(
        &self,
        _req: crate::model::region_notification_endpoints::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::NotificationEndpointList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionNotificationEndpoints::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::region_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::RegionOperations].
///
/// Application developers may need to implement this trait to mock
/// `client::RegionOperations`.  In other use-cases, application developers only
/// use `client::RegionOperations` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "region-operations")]
#[cfg_attr(docsrs, doc(cfg(feature = "region-operations")))]
pub trait RegionOperations: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::RegionOperations::delete].
    fn delete(
        &self,
        _req: crate::model::region_operations::DeleteRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<Output = crate::Result<gax::response::Response<wkt::Empty>>> + Send
    {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionOperations::get].
    fn get(
        &self,
        _req: crate::model::region_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionOperations::list].
    fn list(
        &self,
        _req: crate::model::region_operations::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::OperationList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionOperations::wait].
    fn wait(
        &self,
        _req: crate::model::region_operations::WaitRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }
}

/// Defines the trait used to implement [super::client::RegionSecurityPolicies].
///
/// Application developers may need to implement this trait to mock
/// `client::RegionSecurityPolicies`.  In other use-cases, application developers only
/// use `client::RegionSecurityPolicies` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "region-security-policies")]
#[cfg_attr(docsrs, doc(cfg(feature = "region-security-policies")))]
pub trait RegionSecurityPolicies: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::RegionSecurityPolicies::add_rule].
    fn add_rule(
        &self,
        _req: crate::model::region_security_policies::AddRuleRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionSecurityPolicies::delete].
    fn delete(
        &self,
        _req: crate::model::region_security_policies::DeleteRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionSecurityPolicies::get].
    fn get(
        &self,
        _req: crate::model::region_security_policies::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::SecurityPolicy>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionSecurityPolicies::get_rule].
    fn get_rule(
        &self,
        _req: crate::model::region_security_policies::GetRuleRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::SecurityPolicyRule>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionSecurityPolicies::insert].
    fn insert(
        &self,
        _req: crate::model::region_security_policies::InsertRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionSecurityPolicies::list].
    fn list(
        &self,
        _req: crate::model::region_security_policies::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::SecurityPolicyList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionSecurityPolicies::patch].
    fn patch(
        &self,
        _req: crate::model::region_security_policies::PatchRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionSecurityPolicies::patch_rule].
    fn patch_rule(
        &self,
        _req: crate::model::region_security_policies::PatchRuleRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionSecurityPolicies::remove_rule].
    fn remove_rule(
        &self,
        _req: crate::model::region_security_policies::RemoveRuleRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionSecurityPolicies::set_labels].
    fn set_labels(
        &self,
        _req: crate::model::region_security_policies::SetLabelsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionSecurityPolicies::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::region_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::RegionSslCertificates].
///
/// Application developers may need to implement this trait to mock
/// `client::RegionSslCertificates`.  In other use-cases, application developers only
/// use `client::RegionSslCertificates` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "region-ssl-certificates")]
#[cfg_attr(docsrs, doc(cfg(feature = "region-ssl-certificates")))]
pub trait RegionSslCertificates: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::RegionSslCertificates::delete].
    fn delete(
        &self,
        _req: crate::model::region_ssl_certificates::DeleteRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionSslCertificates::get].
    fn get(
        &self,
        _req: crate::model::region_ssl_certificates::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::SslCertificate>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionSslCertificates::insert].
    fn insert(
        &self,
        _req: crate::model::region_ssl_certificates::InsertRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionSslCertificates::list].
    fn list(
        &self,
        _req: crate::model::region_ssl_certificates::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::SslCertificateList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionSslCertificates::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::region_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::RegionSslPolicies].
///
/// Application developers may need to implement this trait to mock
/// `client::RegionSslPolicies`.  In other use-cases, application developers only
/// use `client::RegionSslPolicies` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "region-ssl-policies")]
#[cfg_attr(docsrs, doc(cfg(feature = "region-ssl-policies")))]
pub trait RegionSslPolicies: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::RegionSslPolicies::delete].
    fn delete(
        &self,
        _req: crate::model::region_ssl_policies::DeleteRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionSslPolicies::get].
    fn get(
        &self,
        _req: crate::model::region_ssl_policies::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::SslPolicy>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionSslPolicies::insert].
    fn insert(
        &self,
        _req: crate::model::region_ssl_policies::InsertRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionSslPolicies::list].
    fn list(
        &self,
        _req: crate::model::region_ssl_policies::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::SslPoliciesList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionSslPolicies::list_available_features].
    fn list_available_features(
        &self,
        _req: crate::model::region_ssl_policies::ListAvailableFeaturesRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<
            gax::response::Response<crate::model::SslPoliciesListAvailableFeaturesResponse>,
        >,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionSslPolicies::patch].
    fn patch(
        &self,
        _req: crate::model::region_ssl_policies::PatchRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionSslPolicies::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::region_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::RegionTargetHttpProxies].
///
/// Application developers may need to implement this trait to mock
/// `client::RegionTargetHttpProxies`.  In other use-cases, application developers only
/// use `client::RegionTargetHttpProxies` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "region-target-http-proxies")]
#[cfg_attr(docsrs, doc(cfg(feature = "region-target-http-proxies")))]
pub trait RegionTargetHttpProxies: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::RegionTargetHttpProxies::delete].
    fn delete(
        &self,
        _req: crate::model::region_target_http_proxies::DeleteRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionTargetHttpProxies::get].
    fn get(
        &self,
        _req: crate::model::region_target_http_proxies::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::TargetHttpProxy>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionTargetHttpProxies::insert].
    fn insert(
        &self,
        _req: crate::model::region_target_http_proxies::InsertRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionTargetHttpProxies::list].
    fn list(
        &self,
        _req: crate::model::region_target_http_proxies::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::TargetHttpProxyList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionTargetHttpProxies::set_url_map].
    fn set_url_map(
        &self,
        _req: crate::model::region_target_http_proxies::SetUrlMapRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionTargetHttpProxies::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::region_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::RegionTargetHttpsProxies].
///
/// Application developers may need to implement this trait to mock
/// `client::RegionTargetHttpsProxies`.  In other use-cases, application developers only
/// use `client::RegionTargetHttpsProxies` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "region-target-https-proxies")]
#[cfg_attr(docsrs, doc(cfg(feature = "region-target-https-proxies")))]
pub trait RegionTargetHttpsProxies: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::RegionTargetHttpsProxies::delete].
    fn delete(
        &self,
        _req: crate::model::region_target_https_proxies::DeleteRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionTargetHttpsProxies::get].
    fn get(
        &self,
        _req: crate::model::region_target_https_proxies::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::TargetHttpsProxy>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionTargetHttpsProxies::insert].
    fn insert(
        &self,
        _req: crate::model::region_target_https_proxies::InsertRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionTargetHttpsProxies::list].
    fn list(
        &self,
        _req: crate::model::region_target_https_proxies::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::TargetHttpsProxyList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionTargetHttpsProxies::patch].
    fn patch(
        &self,
        _req: crate::model::region_target_https_proxies::PatchRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionTargetHttpsProxies::set_ssl_certificates].
    fn set_ssl_certificates(
        &self,
        _req: crate::model::region_target_https_proxies::SetSslCertificatesRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionTargetHttpsProxies::set_url_map].
    fn set_url_map(
        &self,
        _req: crate::model::region_target_https_proxies::SetUrlMapRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionTargetHttpsProxies::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::region_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::RegionTargetTcpProxies].
///
/// Application developers may need to implement this trait to mock
/// `client::RegionTargetTcpProxies`.  In other use-cases, application developers only
/// use `client::RegionTargetTcpProxies` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "region-target-tcp-proxies")]
#[cfg_attr(docsrs, doc(cfg(feature = "region-target-tcp-proxies")))]
pub trait RegionTargetTcpProxies: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::RegionTargetTcpProxies::delete].
    fn delete(
        &self,
        _req: crate::model::region_target_tcp_proxies::DeleteRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionTargetTcpProxies::get].
    fn get(
        &self,
        _req: crate::model::region_target_tcp_proxies::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::TargetTcpProxy>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionTargetTcpProxies::insert].
    fn insert(
        &self,
        _req: crate::model::region_target_tcp_proxies::InsertRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionTargetTcpProxies::list].
    fn list(
        &self,
        _req: crate::model::region_target_tcp_proxies::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::TargetTcpProxyList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionTargetTcpProxies::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::region_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::RegionUrlMaps].
///
/// Application developers may need to implement this trait to mock
/// `client::RegionUrlMaps`.  In other use-cases, application developers only
/// use `client::RegionUrlMaps` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "region-url-maps")]
#[cfg_attr(docsrs, doc(cfg(feature = "region-url-maps")))]
pub trait RegionUrlMaps: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::RegionUrlMaps::delete].
    fn delete(
        &self,
        _req: crate::model::region_url_maps::DeleteRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionUrlMaps::get].
    fn get(
        &self,
        _req: crate::model::region_url_maps::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::UrlMap>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionUrlMaps::insert].
    fn insert(
        &self,
        _req: crate::model::region_url_maps::InsertRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionUrlMaps::list].
    fn list(
        &self,
        _req: crate::model::region_url_maps::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::UrlMapList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionUrlMaps::patch].
    fn patch(
        &self,
        _req: crate::model::region_url_maps::PatchRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionUrlMaps::update].
    fn update(
        &self,
        _req: crate::model::region_url_maps::UpdateRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionUrlMaps::validate].
    fn validate(
        &self,
        _req: crate::model::region_url_maps::ValidateRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::UrlMapsValidateResponse>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::RegionUrlMaps::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::region_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::RegionZones].
///
/// Application developers may need to implement this trait to mock
/// `client::RegionZones`.  In other use-cases, application developers only
/// use `client::RegionZones` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "region-zones")]
#[cfg_attr(docsrs, doc(cfg(feature = "region-zones")))]
pub trait RegionZones: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::RegionZones::list].
    fn list(
        &self,
        _req: crate::model::region_zones::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::ZoneList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }
}

/// Defines the trait used to implement [super::client::Regions].
///
/// Application developers may need to implement this trait to mock
/// `client::Regions`.  In other use-cases, application developers only
/// use `client::Regions` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "regions")]
#[cfg_attr(docsrs, doc(cfg(feature = "regions")))]
pub trait Regions: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::Regions::get].
    fn get(
        &self,
        _req: crate::model::regions::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Region>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Regions::list].
    fn list(
        &self,
        _req: crate::model::regions::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::RegionList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }
}

/// Defines the trait used to implement [super::client::ReservationBlocks].
///
/// Application developers may need to implement this trait to mock
/// `client::ReservationBlocks`.  In other use-cases, application developers only
/// use `client::ReservationBlocks` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "reservation-blocks")]
#[cfg_attr(docsrs, doc(cfg(feature = "reservation-blocks")))]
pub trait ReservationBlocks: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::ReservationBlocks::get].
    fn get(
        &self,
        _req: crate::model::reservation_blocks::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::ReservationBlocksGetResponse>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::ReservationBlocks::get_iam_policy].
    fn get_iam_policy(
        &self,
        _req: crate::model::reservation_blocks::GetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Policy>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::ReservationBlocks::list].
    fn list(
        &self,
        _req: crate::model::reservation_blocks::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<
            gax::response::Response<crate::model::ReservationBlocksListResponse>,
        >,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::ReservationBlocks::perform_maintenance].
    fn perform_maintenance(
        &self,
        _req: crate::model::reservation_blocks::PerformMaintenanceRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::ReservationBlocks::set_iam_policy].
    fn set_iam_policy(
        &self,
        _req: crate::model::reservation_blocks::SetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Policy>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::ReservationBlocks::test_iam_permissions].
    fn test_iam_permissions(
        &self,
        _req: crate::model::reservation_blocks::TestIamPermissionsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::ReservationBlocks::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::zone_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::ReservationSubBlocks].
///
/// Application developers may need to implement this trait to mock
/// `client::ReservationSubBlocks`.  In other use-cases, application developers only
/// use `client::ReservationSubBlocks` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "reservation-sub-blocks")]
#[cfg_attr(docsrs, doc(cfg(feature = "reservation-sub-blocks")))]
pub trait ReservationSubBlocks: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::ReservationSubBlocks::get].
    fn get(
        &self,
        _req: crate::model::reservation_sub_blocks::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<
            gax::response::Response<crate::model::ReservationSubBlocksGetResponse>,
        >,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::ReservationSubBlocks::get_iam_policy].
    fn get_iam_policy(
        &self,
        _req: crate::model::reservation_sub_blocks::GetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Policy>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::ReservationSubBlocks::list].
    fn list(
        &self,
        _req: crate::model::reservation_sub_blocks::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<
            gax::response::Response<crate::model::ReservationSubBlocksListResponse>,
        >,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::ReservationSubBlocks::perform_maintenance].
    fn perform_maintenance(
        &self,
        _req: crate::model::reservation_sub_blocks::PerformMaintenanceRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::ReservationSubBlocks::report_faulty].
    fn report_faulty(
        &self,
        _req: crate::model::reservation_sub_blocks::ReportFaultyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::ReservationSubBlocks::set_iam_policy].
    fn set_iam_policy(
        &self,
        _req: crate::model::reservation_sub_blocks::SetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Policy>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::ReservationSubBlocks::test_iam_permissions].
    fn test_iam_permissions(
        &self,
        _req: crate::model::reservation_sub_blocks::TestIamPermissionsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::ReservationSubBlocks::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::zone_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::Reservations].
///
/// Application developers may need to implement this trait to mock
/// `client::Reservations`.  In other use-cases, application developers only
/// use `client::Reservations` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "reservations")]
#[cfg_attr(docsrs, doc(cfg(feature = "reservations")))]
pub trait Reservations: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::Reservations::aggregated_list].
    fn aggregated_list(
        &self,
        _req: crate::model::reservations::AggregatedListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::ReservationAggregatedList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Reservations::delete].
    fn delete(
        &self,
        _req: crate::model::reservations::DeleteRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Reservations::get].
    fn get(
        &self,
        _req: crate::model::reservations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Reservation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Reservations::get_iam_policy].
    fn get_iam_policy(
        &self,
        _req: crate::model::reservations::GetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Policy>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Reservations::insert].
    fn insert(
        &self,
        _req: crate::model::reservations::InsertRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Reservations::list].
    fn list(
        &self,
        _req: crate::model::reservations::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::ReservationList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Reservations::perform_maintenance].
    fn perform_maintenance(
        &self,
        _req: crate::model::reservations::PerformMaintenanceRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Reservations::resize].
    fn resize(
        &self,
        _req: crate::model::reservations::ResizeRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Reservations::set_iam_policy].
    fn set_iam_policy(
        &self,
        _req: crate::model::reservations::SetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Policy>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Reservations::test_iam_permissions].
    fn test_iam_permissions(
        &self,
        _req: crate::model::reservations::TestIamPermissionsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Reservations::update].
    fn update(
        &self,
        _req: crate::model::reservations::UpdateRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Reservations::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::zone_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::ResourcePolicies].
///
/// Application developers may need to implement this trait to mock
/// `client::ResourcePolicies`.  In other use-cases, application developers only
/// use `client::ResourcePolicies` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "resource-policies")]
#[cfg_attr(docsrs, doc(cfg(feature = "resource-policies")))]
pub trait ResourcePolicies: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::ResourcePolicies::aggregated_list].
    fn aggregated_list(
        &self,
        _req: crate::model::resource_policies::AggregatedListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::ResourcePolicyAggregatedList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::ResourcePolicies::delete].
    fn delete(
        &self,
        _req: crate::model::resource_policies::DeleteRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::ResourcePolicies::get].
    fn get(
        &self,
        _req: crate::model::resource_policies::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::ResourcePolicy>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::ResourcePolicies::get_iam_policy].
    fn get_iam_policy(
        &self,
        _req: crate::model::resource_policies::GetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Policy>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::ResourcePolicies::insert].
    fn insert(
        &self,
        _req: crate::model::resource_policies::InsertRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::ResourcePolicies::list].
    fn list(
        &self,
        _req: crate::model::resource_policies::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::ResourcePolicyList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::ResourcePolicies::patch].
    fn patch(
        &self,
        _req: crate::model::resource_policies::PatchRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::ResourcePolicies::set_iam_policy].
    fn set_iam_policy(
        &self,
        _req: crate::model::resource_policies::SetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Policy>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::ResourcePolicies::test_iam_permissions].
    fn test_iam_permissions(
        &self,
        _req: crate::model::resource_policies::TestIamPermissionsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::ResourcePolicies::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::region_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::Routers].
///
/// Application developers may need to implement this trait to mock
/// `client::Routers`.  In other use-cases, application developers only
/// use `client::Routers` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "routers")]
#[cfg_attr(docsrs, doc(cfg(feature = "routers")))]
pub trait Routers: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::Routers::aggregated_list].
    fn aggregated_list(
        &self,
        _req: crate::model::routers::AggregatedListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::RouterAggregatedList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Routers::delete].
    fn delete(
        &self,
        _req: crate::model::routers::DeleteRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Routers::delete_route_policy].
    fn delete_route_policy(
        &self,
        _req: crate::model::routers::DeleteRoutePolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Routers::get].
    fn get(
        &self,
        _req: crate::model::routers::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Router>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Routers::get_nat_ip_info].
    fn get_nat_ip_info(
        &self,
        _req: crate::model::routers::GetNatIpInfoRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::NatIpInfoResponse>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Routers::get_nat_mapping_info].
    fn get_nat_mapping_info(
        &self,
        _req: crate::model::routers::GetNatMappingInfoRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::VmEndpointNatMappingsList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Routers::get_route_policy].
    fn get_route_policy(
        &self,
        _req: crate::model::routers::GetRoutePolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<
            gax::response::Response<crate::model::RoutersGetRoutePolicyResponse>,
        >,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Routers::get_router_status].
    fn get_router_status(
        &self,
        _req: crate::model::routers::GetRouterStatusRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::RouterStatusResponse>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Routers::insert].
    fn insert(
        &self,
        _req: crate::model::routers::InsertRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Routers::list].
    fn list(
        &self,
        _req: crate::model::routers::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::RouterList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Routers::list_bgp_routes].
    fn list_bgp_routes(
        &self,
        _req: crate::model::routers::ListBgpRoutesRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::RoutersListBgpRoutes>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Routers::list_route_policies].
    fn list_route_policies(
        &self,
        _req: crate::model::routers::ListRoutePoliciesRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::RoutersListRoutePolicies>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Routers::patch].
    fn patch(
        &self,
        _req: crate::model::routers::PatchRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Routers::patch_route_policy].
    fn patch_route_policy(
        &self,
        _req: crate::model::routers::PatchRoutePolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Routers::preview].
    fn preview(
        &self,
        _req: crate::model::routers::PreviewRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::RoutersPreviewResponse>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Routers::update].
    fn update(
        &self,
        _req: crate::model::routers::UpdateRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Routers::update_route_policy].
    fn update_route_policy(
        &self,
        _req: crate::model::routers::UpdateRoutePolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Routers::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::region_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::Routes].
///
/// Application developers may need to implement this trait to mock
/// `client::Routes`.  In other use-cases, application developers only
/// use `client::Routes` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "routes")]
#[cfg_attr(docsrs, doc(cfg(feature = "routes")))]
pub trait Routes: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::Routes::delete].
    fn delete(
        &self,
        _req: crate::model::routes::DeleteRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Routes::get].
    fn get(
        &self,
        _req: crate::model::routes::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Route>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Routes::insert].
    fn insert(
        &self,
        _req: crate::model::routes::InsertRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Routes::list].
    fn list(
        &self,
        _req: crate::model::routes::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::RouteList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Routes::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::global_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::SecurityPolicies].
///
/// Application developers may need to implement this trait to mock
/// `client::SecurityPolicies`.  In other use-cases, application developers only
/// use `client::SecurityPolicies` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "security-policies")]
#[cfg_attr(docsrs, doc(cfg(feature = "security-policies")))]
pub trait SecurityPolicies: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::SecurityPolicies::add_rule].
    fn add_rule(
        &self,
        _req: crate::model::security_policies::AddRuleRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::SecurityPolicies::aggregated_list].
    fn aggregated_list(
        &self,
        _req: crate::model::security_policies::AggregatedListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<
            gax::response::Response<crate::model::SecurityPoliciesAggregatedList>,
        >,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::SecurityPolicies::delete].
    fn delete(
        &self,
        _req: crate::model::security_policies::DeleteRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::SecurityPolicies::get].
    fn get(
        &self,
        _req: crate::model::security_policies::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::SecurityPolicy>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::SecurityPolicies::get_rule].
    fn get_rule(
        &self,
        _req: crate::model::security_policies::GetRuleRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::SecurityPolicyRule>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::SecurityPolicies::insert].
    fn insert(
        &self,
        _req: crate::model::security_policies::InsertRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::SecurityPolicies::list].
    fn list(
        &self,
        _req: crate::model::security_policies::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::SecurityPolicyList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::SecurityPolicies::list_preconfigured_expression_sets].
    fn list_preconfigured_expression_sets(
        &self,
        _req: crate::model::security_policies::ListPreconfiguredExpressionSetsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<
            gax::response::Response<
                crate::model::SecurityPoliciesListPreconfiguredExpressionSetsResponse,
            >,
        >,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::SecurityPolicies::patch].
    fn patch(
        &self,
        _req: crate::model::security_policies::PatchRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::SecurityPolicies::patch_rule].
    fn patch_rule(
        &self,
        _req: crate::model::security_policies::PatchRuleRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::SecurityPolicies::remove_rule].
    fn remove_rule(
        &self,
        _req: crate::model::security_policies::RemoveRuleRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::SecurityPolicies::set_labels].
    fn set_labels(
        &self,
        _req: crate::model::security_policies::SetLabelsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::SecurityPolicies::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::global_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::ServiceAttachments].
///
/// Application developers may need to implement this trait to mock
/// `client::ServiceAttachments`.  In other use-cases, application developers only
/// use `client::ServiceAttachments` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "service-attachments")]
#[cfg_attr(docsrs, doc(cfg(feature = "service-attachments")))]
pub trait ServiceAttachments: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::ServiceAttachments::aggregated_list].
    fn aggregated_list(
        &self,
        _req: crate::model::service_attachments::AggregatedListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<
            gax::response::Response<crate::model::ServiceAttachmentAggregatedList>,
        >,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::ServiceAttachments::delete].
    fn delete(
        &self,
        _req: crate::model::service_attachments::DeleteRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::ServiceAttachments::get].
    fn get(
        &self,
        _req: crate::model::service_attachments::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::ServiceAttachment>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::ServiceAttachments::get_iam_policy].
    fn get_iam_policy(
        &self,
        _req: crate::model::service_attachments::GetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Policy>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::ServiceAttachments::insert].
    fn insert(
        &self,
        _req: crate::model::service_attachments::InsertRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::ServiceAttachments::list].
    fn list(
        &self,
        _req: crate::model::service_attachments::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::ServiceAttachmentList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::ServiceAttachments::patch].
    fn patch(
        &self,
        _req: crate::model::service_attachments::PatchRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::ServiceAttachments::set_iam_policy].
    fn set_iam_policy(
        &self,
        _req: crate::model::service_attachments::SetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Policy>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::ServiceAttachments::test_iam_permissions].
    fn test_iam_permissions(
        &self,
        _req: crate::model::service_attachments::TestIamPermissionsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::ServiceAttachments::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::region_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::SnapshotSettings].
///
/// Application developers may need to implement this trait to mock
/// `client::SnapshotSettings`.  In other use-cases, application developers only
/// use `client::SnapshotSettings` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "snapshot-settings")]
#[cfg_attr(docsrs, doc(cfg(feature = "snapshot-settings")))]
pub trait SnapshotSettings: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::SnapshotSettings::get].
    fn get(
        &self,
        _req: crate::model::snapshot_settings::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::SnapshotSettings>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::SnapshotSettings::patch].
    fn patch(
        &self,
        _req: crate::model::snapshot_settings::PatchRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::SnapshotSettings::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::global_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::Snapshots].
///
/// Application developers may need to implement this trait to mock
/// `client::Snapshots`.  In other use-cases, application developers only
/// use `client::Snapshots` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "snapshots")]
#[cfg_attr(docsrs, doc(cfg(feature = "snapshots")))]
pub trait Snapshots: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::Snapshots::delete].
    fn delete(
        &self,
        _req: crate::model::snapshots::DeleteRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Snapshots::get].
    fn get(
        &self,
        _req: crate::model::snapshots::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Snapshot>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Snapshots::get_iam_policy].
    fn get_iam_policy(
        &self,
        _req: crate::model::snapshots::GetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Policy>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Snapshots::insert].
    fn insert(
        &self,
        _req: crate::model::snapshots::InsertRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Snapshots::list].
    fn list(
        &self,
        _req: crate::model::snapshots::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::SnapshotList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Snapshots::set_iam_policy].
    fn set_iam_policy(
        &self,
        _req: crate::model::snapshots::SetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Policy>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Snapshots::set_labels].
    fn set_labels(
        &self,
        _req: crate::model::snapshots::SetLabelsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Snapshots::test_iam_permissions].
    fn test_iam_permissions(
        &self,
        _req: crate::model::snapshots::TestIamPermissionsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Snapshots::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::global_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::SslCertificates].
///
/// Application developers may need to implement this trait to mock
/// `client::SslCertificates`.  In other use-cases, application developers only
/// use `client::SslCertificates` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "ssl-certificates")]
#[cfg_attr(docsrs, doc(cfg(feature = "ssl-certificates")))]
pub trait SslCertificates: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::SslCertificates::aggregated_list].
    fn aggregated_list(
        &self,
        _req: crate::model::ssl_certificates::AggregatedListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::SslCertificateAggregatedList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::SslCertificates::delete].
    fn delete(
        &self,
        _req: crate::model::ssl_certificates::DeleteRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::SslCertificates::get].
    fn get(
        &self,
        _req: crate::model::ssl_certificates::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::SslCertificate>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::SslCertificates::insert].
    fn insert(
        &self,
        _req: crate::model::ssl_certificates::InsertRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::SslCertificates::list].
    fn list(
        &self,
        _req: crate::model::ssl_certificates::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::SslCertificateList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::SslCertificates::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::global_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::SslPolicies].
///
/// Application developers may need to implement this trait to mock
/// `client::SslPolicies`.  In other use-cases, application developers only
/// use `client::SslPolicies` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "ssl-policies")]
#[cfg_attr(docsrs, doc(cfg(feature = "ssl-policies")))]
pub trait SslPolicies: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::SslPolicies::aggregated_list].
    fn aggregated_list(
        &self,
        _req: crate::model::ssl_policies::AggregatedListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::SslPoliciesAggregatedList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::SslPolicies::delete].
    fn delete(
        &self,
        _req: crate::model::ssl_policies::DeleteRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::SslPolicies::get].
    fn get(
        &self,
        _req: crate::model::ssl_policies::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::SslPolicy>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::SslPolicies::insert].
    fn insert(
        &self,
        _req: crate::model::ssl_policies::InsertRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::SslPolicies::list].
    fn list(
        &self,
        _req: crate::model::ssl_policies::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::SslPoliciesList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::SslPolicies::list_available_features].
    fn list_available_features(
        &self,
        _req: crate::model::ssl_policies::ListAvailableFeaturesRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<
            gax::response::Response<crate::model::SslPoliciesListAvailableFeaturesResponse>,
        >,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::SslPolicies::patch].
    fn patch(
        &self,
        _req: crate::model::ssl_policies::PatchRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::SslPolicies::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::global_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::StoragePoolTypes].
///
/// Application developers may need to implement this trait to mock
/// `client::StoragePoolTypes`.  In other use-cases, application developers only
/// use `client::StoragePoolTypes` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "storage-pool-types")]
#[cfg_attr(docsrs, doc(cfg(feature = "storage-pool-types")))]
pub trait StoragePoolTypes: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::StoragePoolTypes::aggregated_list].
    fn aggregated_list(
        &self,
        _req: crate::model::storage_pool_types::AggregatedListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<
            gax::response::Response<crate::model::StoragePoolTypeAggregatedList>,
        >,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::StoragePoolTypes::get].
    fn get(
        &self,
        _req: crate::model::storage_pool_types::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::StoragePoolType>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::StoragePoolTypes::list].
    fn list(
        &self,
        _req: crate::model::storage_pool_types::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::StoragePoolTypeList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }
}

/// Defines the trait used to implement [super::client::StoragePools].
///
/// Application developers may need to implement this trait to mock
/// `client::StoragePools`.  In other use-cases, application developers only
/// use `client::StoragePools` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "storage-pools")]
#[cfg_attr(docsrs, doc(cfg(feature = "storage-pools")))]
pub trait StoragePools: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::StoragePools::aggregated_list].
    fn aggregated_list(
        &self,
        _req: crate::model::storage_pools::AggregatedListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::StoragePoolAggregatedList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::StoragePools::delete].
    fn delete(
        &self,
        _req: crate::model::storage_pools::DeleteRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::StoragePools::get].
    fn get(
        &self,
        _req: crate::model::storage_pools::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::StoragePool>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::StoragePools::get_iam_policy].
    fn get_iam_policy(
        &self,
        _req: crate::model::storage_pools::GetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Policy>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::StoragePools::insert].
    fn insert(
        &self,
        _req: crate::model::storage_pools::InsertRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::StoragePools::list].
    fn list(
        &self,
        _req: crate::model::storage_pools::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::StoragePoolList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::StoragePools::list_disks].
    fn list_disks(
        &self,
        _req: crate::model::storage_pools::ListDisksRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::StoragePoolListDisks>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::StoragePools::set_iam_policy].
    fn set_iam_policy(
        &self,
        _req: crate::model::storage_pools::SetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Policy>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::StoragePools::test_iam_permissions].
    fn test_iam_permissions(
        &self,
        _req: crate::model::storage_pools::TestIamPermissionsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::StoragePools::update].
    fn update(
        &self,
        _req: crate::model::storage_pools::UpdateRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::StoragePools::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::zone_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::Subnetworks].
///
/// Application developers may need to implement this trait to mock
/// `client::Subnetworks`.  In other use-cases, application developers only
/// use `client::Subnetworks` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "subnetworks")]
#[cfg_attr(docsrs, doc(cfg(feature = "subnetworks")))]
pub trait Subnetworks: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::Subnetworks::aggregated_list].
    fn aggregated_list(
        &self,
        _req: crate::model::subnetworks::AggregatedListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::SubnetworkAggregatedList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Subnetworks::delete].
    fn delete(
        &self,
        _req: crate::model::subnetworks::DeleteRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Subnetworks::expand_ip_cidr_range].
    fn expand_ip_cidr_range(
        &self,
        _req: crate::model::subnetworks::ExpandIpCidrRangeRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Subnetworks::get].
    fn get(
        &self,
        _req: crate::model::subnetworks::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Subnetwork>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Subnetworks::get_iam_policy].
    fn get_iam_policy(
        &self,
        _req: crate::model::subnetworks::GetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Policy>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Subnetworks::insert].
    fn insert(
        &self,
        _req: crate::model::subnetworks::InsertRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Subnetworks::list].
    fn list(
        &self,
        _req: crate::model::subnetworks::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::SubnetworkList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Subnetworks::list_usable].
    fn list_usable(
        &self,
        _req: crate::model::subnetworks::ListUsableRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<
            gax::response::Response<crate::model::UsableSubnetworksAggregatedList>,
        >,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Subnetworks::patch].
    fn patch(
        &self,
        _req: crate::model::subnetworks::PatchRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Subnetworks::set_iam_policy].
    fn set_iam_policy(
        &self,
        _req: crate::model::subnetworks::SetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Policy>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Subnetworks::set_private_ip_google_access].
    fn set_private_ip_google_access(
        &self,
        _req: crate::model::subnetworks::SetPrivateIpGoogleAccessRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Subnetworks::test_iam_permissions].
    fn test_iam_permissions(
        &self,
        _req: crate::model::subnetworks::TestIamPermissionsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Subnetworks::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::region_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::TargetGrpcProxies].
///
/// Application developers may need to implement this trait to mock
/// `client::TargetGrpcProxies`.  In other use-cases, application developers only
/// use `client::TargetGrpcProxies` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "target-grpc-proxies")]
#[cfg_attr(docsrs, doc(cfg(feature = "target-grpc-proxies")))]
pub trait TargetGrpcProxies: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::TargetGrpcProxies::delete].
    fn delete(
        &self,
        _req: crate::model::target_grpc_proxies::DeleteRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::TargetGrpcProxies::get].
    fn get(
        &self,
        _req: crate::model::target_grpc_proxies::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::TargetGrpcProxy>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::TargetGrpcProxies::insert].
    fn insert(
        &self,
        _req: crate::model::target_grpc_proxies::InsertRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::TargetGrpcProxies::list].
    fn list(
        &self,
        _req: crate::model::target_grpc_proxies::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::TargetGrpcProxyList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::TargetGrpcProxies::patch].
    fn patch(
        &self,
        _req: crate::model::target_grpc_proxies::PatchRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::TargetGrpcProxies::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::global_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::TargetHttpProxies].
///
/// Application developers may need to implement this trait to mock
/// `client::TargetHttpProxies`.  In other use-cases, application developers only
/// use `client::TargetHttpProxies` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "target-http-proxies")]
#[cfg_attr(docsrs, doc(cfg(feature = "target-http-proxies")))]
pub trait TargetHttpProxies: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::TargetHttpProxies::aggregated_list].
    fn aggregated_list(
        &self,
        _req: crate::model::target_http_proxies::AggregatedListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<
            gax::response::Response<crate::model::TargetHttpProxyAggregatedList>,
        >,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::TargetHttpProxies::delete].
    fn delete(
        &self,
        _req: crate::model::target_http_proxies::DeleteRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::TargetHttpProxies::get].
    fn get(
        &self,
        _req: crate::model::target_http_proxies::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::TargetHttpProxy>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::TargetHttpProxies::insert].
    fn insert(
        &self,
        _req: crate::model::target_http_proxies::InsertRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::TargetHttpProxies::list].
    fn list(
        &self,
        _req: crate::model::target_http_proxies::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::TargetHttpProxyList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::TargetHttpProxies::patch].
    fn patch(
        &self,
        _req: crate::model::target_http_proxies::PatchRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::TargetHttpProxies::set_url_map].
    fn set_url_map(
        &self,
        _req: crate::model::target_http_proxies::SetUrlMapRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::TargetHttpProxies::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::global_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::TargetHttpsProxies].
///
/// Application developers may need to implement this trait to mock
/// `client::TargetHttpsProxies`.  In other use-cases, application developers only
/// use `client::TargetHttpsProxies` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "target-https-proxies")]
#[cfg_attr(docsrs, doc(cfg(feature = "target-https-proxies")))]
pub trait TargetHttpsProxies: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::TargetHttpsProxies::aggregated_list].
    fn aggregated_list(
        &self,
        _req: crate::model::target_https_proxies::AggregatedListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<
            gax::response::Response<crate::model::TargetHttpsProxyAggregatedList>,
        >,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::TargetHttpsProxies::delete].
    fn delete(
        &self,
        _req: crate::model::target_https_proxies::DeleteRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::TargetHttpsProxies::get].
    fn get(
        &self,
        _req: crate::model::target_https_proxies::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::TargetHttpsProxy>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::TargetHttpsProxies::insert].
    fn insert(
        &self,
        _req: crate::model::target_https_proxies::InsertRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::TargetHttpsProxies::list].
    fn list(
        &self,
        _req: crate::model::target_https_proxies::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::TargetHttpsProxyList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::TargetHttpsProxies::patch].
    fn patch(
        &self,
        _req: crate::model::target_https_proxies::PatchRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::TargetHttpsProxies::set_certificate_map].
    fn set_certificate_map(
        &self,
        _req: crate::model::target_https_proxies::SetCertificateMapRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::TargetHttpsProxies::set_quic_override].
    fn set_quic_override(
        &self,
        _req: crate::model::target_https_proxies::SetQuicOverrideRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::TargetHttpsProxies::set_ssl_certificates].
    fn set_ssl_certificates(
        &self,
        _req: crate::model::target_https_proxies::SetSslCertificatesRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::TargetHttpsProxies::set_ssl_policy].
    fn set_ssl_policy(
        &self,
        _req: crate::model::target_https_proxies::SetSslPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::TargetHttpsProxies::set_url_map].
    fn set_url_map(
        &self,
        _req: crate::model::target_https_proxies::SetUrlMapRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::TargetHttpsProxies::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::global_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::TargetInstances].
///
/// Application developers may need to implement this trait to mock
/// `client::TargetInstances`.  In other use-cases, application developers only
/// use `client::TargetInstances` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "target-instances")]
#[cfg_attr(docsrs, doc(cfg(feature = "target-instances")))]
pub trait TargetInstances: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::TargetInstances::aggregated_list].
    fn aggregated_list(
        &self,
        _req: crate::model::target_instances::AggregatedListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::TargetInstanceAggregatedList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::TargetInstances::delete].
    fn delete(
        &self,
        _req: crate::model::target_instances::DeleteRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::TargetInstances::get].
    fn get(
        &self,
        _req: crate::model::target_instances::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::TargetInstance>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::TargetInstances::insert].
    fn insert(
        &self,
        _req: crate::model::target_instances::InsertRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::TargetInstances::list].
    fn list(
        &self,
        _req: crate::model::target_instances::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::TargetInstanceList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::TargetInstances::set_security_policy].
    fn set_security_policy(
        &self,
        _req: crate::model::target_instances::SetSecurityPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::TargetInstances::test_iam_permissions].
    fn test_iam_permissions(
        &self,
        _req: crate::model::target_instances::TestIamPermissionsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::TargetInstances::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::zone_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::TargetPools].
///
/// Application developers may need to implement this trait to mock
/// `client::TargetPools`.  In other use-cases, application developers only
/// use `client::TargetPools` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "target-pools")]
#[cfg_attr(docsrs, doc(cfg(feature = "target-pools")))]
pub trait TargetPools: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::TargetPools::add_health_check].
    fn add_health_check(
        &self,
        _req: crate::model::target_pools::AddHealthCheckRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::TargetPools::add_instance].
    fn add_instance(
        &self,
        _req: crate::model::target_pools::AddInstanceRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::TargetPools::aggregated_list].
    fn aggregated_list(
        &self,
        _req: crate::model::target_pools::AggregatedListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::TargetPoolAggregatedList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::TargetPools::delete].
    fn delete(
        &self,
        _req: crate::model::target_pools::DeleteRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::TargetPools::get].
    fn get(
        &self,
        _req: crate::model::target_pools::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::TargetPool>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::TargetPools::get_health].
    fn get_health(
        &self,
        _req: crate::model::target_pools::GetHealthRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::TargetPoolInstanceHealth>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::TargetPools::insert].
    fn insert(
        &self,
        _req: crate::model::target_pools::InsertRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::TargetPools::list].
    fn list(
        &self,
        _req: crate::model::target_pools::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::TargetPoolList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::TargetPools::remove_health_check].
    fn remove_health_check(
        &self,
        _req: crate::model::target_pools::RemoveHealthCheckRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::TargetPools::remove_instance].
    fn remove_instance(
        &self,
        _req: crate::model::target_pools::RemoveInstanceRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::TargetPools::set_backup].
    fn set_backup(
        &self,
        _req: crate::model::target_pools::SetBackupRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::TargetPools::set_security_policy].
    fn set_security_policy(
        &self,
        _req: crate::model::target_pools::SetSecurityPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::TargetPools::test_iam_permissions].
    fn test_iam_permissions(
        &self,
        _req: crate::model::target_pools::TestIamPermissionsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::TargetPools::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::region_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::TargetSslProxies].
///
/// Application developers may need to implement this trait to mock
/// `client::TargetSslProxies`.  In other use-cases, application developers only
/// use `client::TargetSslProxies` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "target-ssl-proxies")]
#[cfg_attr(docsrs, doc(cfg(feature = "target-ssl-proxies")))]
pub trait TargetSslProxies: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::TargetSslProxies::delete].
    fn delete(
        &self,
        _req: crate::model::target_ssl_proxies::DeleteRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::TargetSslProxies::get].
    fn get(
        &self,
        _req: crate::model::target_ssl_proxies::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::TargetSslProxy>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::TargetSslProxies::insert].
    fn insert(
        &self,
        _req: crate::model::target_ssl_proxies::InsertRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::TargetSslProxies::list].
    fn list(
        &self,
        _req: crate::model::target_ssl_proxies::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::TargetSslProxyList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::TargetSslProxies::set_backend_service].
    fn set_backend_service(
        &self,
        _req: crate::model::target_ssl_proxies::SetBackendServiceRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::TargetSslProxies::set_certificate_map].
    fn set_certificate_map(
        &self,
        _req: crate::model::target_ssl_proxies::SetCertificateMapRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::TargetSslProxies::set_proxy_header].
    fn set_proxy_header(
        &self,
        _req: crate::model::target_ssl_proxies::SetProxyHeaderRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::TargetSslProxies::set_ssl_certificates].
    fn set_ssl_certificates(
        &self,
        _req: crate::model::target_ssl_proxies::SetSslCertificatesRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::TargetSslProxies::set_ssl_policy].
    fn set_ssl_policy(
        &self,
        _req: crate::model::target_ssl_proxies::SetSslPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::TargetSslProxies::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::global_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::TargetTcpProxies].
///
/// Application developers may need to implement this trait to mock
/// `client::TargetTcpProxies`.  In other use-cases, application developers only
/// use `client::TargetTcpProxies` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "target-tcp-proxies")]
#[cfg_attr(docsrs, doc(cfg(feature = "target-tcp-proxies")))]
pub trait TargetTcpProxies: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::TargetTcpProxies::aggregated_list].
    fn aggregated_list(
        &self,
        _req: crate::model::target_tcp_proxies::AggregatedListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::TargetTcpProxyAggregatedList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::TargetTcpProxies::delete].
    fn delete(
        &self,
        _req: crate::model::target_tcp_proxies::DeleteRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::TargetTcpProxies::get].
    fn get(
        &self,
        _req: crate::model::target_tcp_proxies::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::TargetTcpProxy>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::TargetTcpProxies::insert].
    fn insert(
        &self,
        _req: crate::model::target_tcp_proxies::InsertRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::TargetTcpProxies::list].
    fn list(
        &self,
        _req: crate::model::target_tcp_proxies::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::TargetTcpProxyList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::TargetTcpProxies::set_backend_service].
    fn set_backend_service(
        &self,
        _req: crate::model::target_tcp_proxies::SetBackendServiceRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::TargetTcpProxies::set_proxy_header].
    fn set_proxy_header(
        &self,
        _req: crate::model::target_tcp_proxies::SetProxyHeaderRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::TargetTcpProxies::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::global_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::TargetVpnGateways].
///
/// Application developers may need to implement this trait to mock
/// `client::TargetVpnGateways`.  In other use-cases, application developers only
/// use `client::TargetVpnGateways` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "target-vpn-gateways")]
#[cfg_attr(docsrs, doc(cfg(feature = "target-vpn-gateways")))]
pub trait TargetVpnGateways: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::TargetVpnGateways::aggregated_list].
    fn aggregated_list(
        &self,
        _req: crate::model::target_vpn_gateways::AggregatedListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<
            gax::response::Response<crate::model::TargetVpnGatewayAggregatedList>,
        >,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::TargetVpnGateways::delete].
    fn delete(
        &self,
        _req: crate::model::target_vpn_gateways::DeleteRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::TargetVpnGateways::get].
    fn get(
        &self,
        _req: crate::model::target_vpn_gateways::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::TargetVpnGateway>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::TargetVpnGateways::insert].
    fn insert(
        &self,
        _req: crate::model::target_vpn_gateways::InsertRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::TargetVpnGateways::list].
    fn list(
        &self,
        _req: crate::model::target_vpn_gateways::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::TargetVpnGatewayList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::TargetVpnGateways::set_labels].
    fn set_labels(
        &self,
        _req: crate::model::target_vpn_gateways::SetLabelsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::TargetVpnGateways::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::region_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::UrlMaps].
///
/// Application developers may need to implement this trait to mock
/// `client::UrlMaps`.  In other use-cases, application developers only
/// use `client::UrlMaps` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "url-maps")]
#[cfg_attr(docsrs, doc(cfg(feature = "url-maps")))]
pub trait UrlMaps: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::UrlMaps::aggregated_list].
    fn aggregated_list(
        &self,
        _req: crate::model::url_maps::AggregatedListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::UrlMapsAggregatedList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::UrlMaps::delete].
    fn delete(
        &self,
        _req: crate::model::url_maps::DeleteRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::UrlMaps::get].
    fn get(
        &self,
        _req: crate::model::url_maps::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::UrlMap>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::UrlMaps::insert].
    fn insert(
        &self,
        _req: crate::model::url_maps::InsertRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::UrlMaps::invalidate_cache].
    fn invalidate_cache(
        &self,
        _req: crate::model::url_maps::InvalidateCacheRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::UrlMaps::list].
    fn list(
        &self,
        _req: crate::model::url_maps::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::UrlMapList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::UrlMaps::patch].
    fn patch(
        &self,
        _req: crate::model::url_maps::PatchRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::UrlMaps::update].
    fn update(
        &self,
        _req: crate::model::url_maps::UpdateRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::UrlMaps::validate].
    fn validate(
        &self,
        _req: crate::model::url_maps::ValidateRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::UrlMapsValidateResponse>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::UrlMaps::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::global_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::VpnGateways].
///
/// Application developers may need to implement this trait to mock
/// `client::VpnGateways`.  In other use-cases, application developers only
/// use `client::VpnGateways` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "vpn-gateways")]
#[cfg_attr(docsrs, doc(cfg(feature = "vpn-gateways")))]
pub trait VpnGateways: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::VpnGateways::aggregated_list].
    fn aggregated_list(
        &self,
        _req: crate::model::vpn_gateways::AggregatedListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::VpnGatewayAggregatedList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::VpnGateways::delete].
    fn delete(
        &self,
        _req: crate::model::vpn_gateways::DeleteRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::VpnGateways::get].
    fn get(
        &self,
        _req: crate::model::vpn_gateways::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::VpnGateway>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::VpnGateways::get_status].
    fn get_status(
        &self,
        _req: crate::model::vpn_gateways::GetStatusRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::VpnGatewaysGetStatusResponse>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::VpnGateways::insert].
    fn insert(
        &self,
        _req: crate::model::vpn_gateways::InsertRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::VpnGateways::list].
    fn list(
        &self,
        _req: crate::model::vpn_gateways::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::VpnGatewayList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::VpnGateways::set_labels].
    fn set_labels(
        &self,
        _req: crate::model::vpn_gateways::SetLabelsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::VpnGateways::test_iam_permissions].
    fn test_iam_permissions(
        &self,
        _req: crate::model::vpn_gateways::TestIamPermissionsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::TestPermissionsResponse>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::VpnGateways::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::region_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::VpnTunnels].
///
/// Application developers may need to implement this trait to mock
/// `client::VpnTunnels`.  In other use-cases, application developers only
/// use `client::VpnTunnels` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "vpn-tunnels")]
#[cfg_attr(docsrs, doc(cfg(feature = "vpn-tunnels")))]
pub trait VpnTunnels: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::VpnTunnels::aggregated_list].
    fn aggregated_list(
        &self,
        _req: crate::model::vpn_tunnels::AggregatedListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::VpnTunnelAggregatedList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::VpnTunnels::delete].
    fn delete(
        &self,
        _req: crate::model::vpn_tunnels::DeleteRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::VpnTunnels::get].
    fn get(
        &self,
        _req: crate::model::vpn_tunnels::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::VpnTunnel>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::VpnTunnels::insert].
    fn insert(
        &self,
        _req: crate::model::vpn_tunnels::InsertRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::VpnTunnels::list].
    fn list(
        &self,
        _req: crate::model::vpn_tunnels::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::VpnTunnelList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::VpnTunnels::set_labels].
    fn set_labels(
        &self,
        _req: crate::model::vpn_tunnels::SetLabelsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::VpnTunnels::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::region_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::WireGroups].
///
/// Application developers may need to implement this trait to mock
/// `client::WireGroups`.  In other use-cases, application developers only
/// use `client::WireGroups` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "wire-groups")]
#[cfg_attr(docsrs, doc(cfg(feature = "wire-groups")))]
pub trait WireGroups: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::WireGroups::delete].
    fn delete(
        &self,
        _req: crate::model::wire_groups::DeleteRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::WireGroups::get].
    fn get(
        &self,
        _req: crate::model::wire_groups::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::WireGroup>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::WireGroups::insert].
    fn insert(
        &self,
        _req: crate::model::wire_groups::InsertRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::WireGroups::list].
    fn list(
        &self,
        _req: crate::model::wire_groups::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::WireGroupList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::WireGroups::patch].
    fn patch(
        &self,
        _req: crate::model::wire_groups::PatchRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::WireGroups::get_operation].
    fn get_operation(
        &self,
        _req: crate::model::global_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::ZoneOperations].
///
/// Application developers may need to implement this trait to mock
/// `client::ZoneOperations`.  In other use-cases, application developers only
/// use `client::ZoneOperations` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "zone-operations")]
#[cfg_attr(docsrs, doc(cfg(feature = "zone-operations")))]
pub trait ZoneOperations: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::ZoneOperations::delete].
    fn delete(
        &self,
        _req: crate::model::zone_operations::DeleteRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<Output = crate::Result<gax::response::Response<wkt::Empty>>> + Send
    {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::ZoneOperations::get].
    fn get(
        &self,
        _req: crate::model::zone_operations::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::ZoneOperations::list].
    fn list(
        &self,
        _req: crate::model::zone_operations::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::OperationList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::ZoneOperations::wait].
    fn wait(
        &self,
        _req: crate::model::zone_operations::WaitRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }
}

/// Defines the trait used to implement [super::client::Zones].
///
/// Application developers may need to implement this trait to mock
/// `client::Zones`.  In other use-cases, application developers only
/// use `client::Zones` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "zones")]
#[cfg_attr(docsrs, doc(cfg(feature = "zones")))]
pub trait Zones: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::Zones::get].
    fn get(
        &self,
        _req: crate::model::zones::GetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Zone>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }

    /// Implements [super::client::Zones::list].
    fn list(
        &self,
        _req: crate::model::zones::ListRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::ZoneList>>,
    > + Send {
        gaxi::unimplemented::unimplemented_stub()
    }
}
